************widgets*************
1)BitmapCroppingWorkerTask.java
===============================
1)BitmapCroppingWorkerTask.java
===============================
// "Therefore those skilled at the unorthodox// are infinite as heaven and earth,// inexhaustible as the great rivers.// When they come to an end,// they begin again,// like the days and months;// they die and are reborn,// like the four seasons."//// - Sun Tsu,// "The Art of War" package com.eppico.widgets; import android.content.Context;import android.graphics.Bitmap;import android.graphics.Rect;import android.net.Uri;import android.os.AsyncTask; import com.eppico.cropwindow.ImageViewUtil; import java.lang.ref.WeakReference; /** * Task to crop bitmap asynchronously from the UI thread. */class BitmapCroppingWorkerTask extends AsyncTask<Void, Void, BitmapCroppingWorkerTask.Result> { //region: Fields and Consts /** * Use a WeakReference to ensure the ImageView can be garbage collected */ private final WeakReference<CropImageView> mCropImageViewReference; /** * the bitmap to crop */ private final Bitmap mBitmap; /** * The Android URI of the image to load */ private final Uri mUri; /** * The context of the crop image view widget used for loading of bitmap by Android URI */ private final Context mContext; /** * Required cropping rectangle */ private final Rect mRect; /** * The shape to crop the image */ private final CropImageView.CropShape mCropShape; /** * Degrees the image was rotated after loading */ private final int mDegreesRotated; /** * required width of the cropping image */ private final int mReqWidth; /** * required height of the cropping image */ private final int mReqHeight; //endregion public BitmapCroppingWorkerTask(CropImageView cropImageView, Bitmap bitmap, Rect rect, CropImageView.CropShape cropShape) { mCropImageViewReference = new WeakReference<>(cropImageView); mContext = cropImageView.getContext(); mBitmap = bitmap; mRect = rect; mCropShape = cropShape; mUri = null; mDegreesRotated = 0; mReqWidth = 0; mReqHeight = 0; } public BitmapCroppingWorkerTask(CropImageView cropImageView, Uri uri, Rect rect, CropImageView.CropShape cropShape, int degreesRotated, int reqWidth, int reqHeight) { mCropImageViewReference = new WeakReference<>(cropImageView); mContext = cropImageView.getContext(); mUri = uri; mRect = rect; mCropShape = cropShape; mDegreesRotated = degreesRotated; mReqWidth = reqWidth; mReqHeight = reqHeight; mBitmap = null; } /** * The Android URI that this task is currently loading. */ public Uri getUri() { return mUri; } /** * Crop image in background. * * @param params ignored * @return the decoded bitmap data */ @Override protected Result doInBackground(Void... params) { try { if (!isCancelled()) { Bitmap bitmap = null; if (mUri != null) { bitmap = ImageViewUtil.cropBitmap( mContext, mUri, mRect, mDegreesRotated, mReqWidth, mReqHeight); } else if (mBitmap != null) { bitmap = ImageViewUtil.cropBitmap(mBitmap, mRect); } if (bitmap != null && mCropShape == CropImageView.CropShape.OVAL) { bitmap = ImageViewUtil.toOvalBitmap(bitmap); } return new Result(bitmap); } return null; } catch (Exception e) { return new Result(e); } } /** * Once complete, see if ImageView is still around and set bitmap. * * @param result the result of bitmap cropping */ @Override protected void onPostExecute(Result result) { if (result != null) { boolean completeCalled = false; if (!isCancelled()) { CropImageView cropImageView = mCropImageViewReference.get(); if (cropImageView != null) { completeCalled = true; cropImageView.onGetImageCroppingAsyncComplete(result); } } if (!completeCalled && result.bitmap != null) { // fast release of unused bitmap result.bitmap.recycle(); } } } //region: Inner class: Result /** * The result of BitmapCroppingWorkerTask async loading. */ public static final class Result { /** * The cropped bitmap */ public final Bitmap bitmap; /** * The error that occurred during async bitmap cropping. */ public final Exception error; Result(Bitmap bitmap) { this.bitmap = bitmap; this.error = null; } Result(Exception error) { this.bitmap = null; this.error = error; } } //endregion}
2)BitmapLoadingWorkerTask.java
==============================
// "Therefore those skilled at the unorthodox// are infinite as heaven and earth,// inexhaustible as the great rivers.// When they come to an end,// they begin again,// like the days and months;// they die and are reborn,// like the four seasons."//// - Sun Tsu,// "The Art of War" package com.eppico.widgets; import android.content.Context;import android.graphics.Bitmap;import android.net.Uri;import android.os.AsyncTask;import android.util.DisplayMetrics; import com.eppico.cropwindow.ImageViewUtil; import java.lang.ref.WeakReference; /** * Task to load bitmap asynchronously from the UI thread. */class BitmapLoadingWorkerTask extends AsyncTask<Void, Void, BitmapLoadingWorkerTask.Result> { //region: Fields and Consts /** * Use a WeakReference to ensure the ImageView can be garbage collected */ private final WeakReference<CropImageView> mCropImageViewReference; /** * The Android URI of the image to load */ private final Uri mUri; /** * Optional: if given use this rotation and not by exif */ private final Integer mPreSetRotation; /** * The context of the crop image view widget used for loading of bitmap by Android URI */ private final Context mContext; /** * required width of the cropping image after density adjustment */ private final int mWidth; /** * required height of the cropping image after density adjustment */ private final int mHeight; //endregion public BitmapLoadingWorkerTask(CropImageView cropImageView, Uri uri, Integer preSetRotation) { mUri = uri; mPreSetRotation = preSetRotation; mCropImageViewReference = new WeakReference<>(cropImageView); mContext = cropImageView.getContext(); DisplayMetrics metrics = cropImageView.getResources().getDisplayMetrics(); double densityAdj = metrics.density > 1 ? 1 / metrics.density : 1; mWidth = (int) (metrics.widthPixels * densityAdj); mHeight = (int) (metrics.heightPixels * densityAdj); } /** * The Android URI that this task is currently loading. */ public Uri getUri() { return mUri; } /** * Decode image in background. * * @param params ignored * @return the decoded bitmap data */ @Override protected Result doInBackground(Void... params) { try { if (!isCancelled()) { ImageViewUtil.DecodeBitmapResult decodeResult = ImageViewUtil.decodeSampledBitmap(mContext, mUri, mWidth, mHeight); if (!isCancelled()) { ImageViewUtil.RotateBitmapResult rotateResult = mPreSetRotation != null ? ImageViewUtil.rotateBitmapResult(decodeResult.bitmap, mPreSetRotation) : ImageViewUtil.rotateBitmapByExif(mContext, decodeResult.bitmap, mUri); return new Result(mUri, rotateResult.bitmap, decodeResult.sampleSize, rotateResult.degrees); } } return null; } catch (Exception e) { return new Result(mUri, e); } } /** * Once complete, see if ImageView is still around and set bitmap. * * @param result the result of bitmap loading */ @Override protected void onPostExecute(Result result) { if (result != null) { boolean completeCalled = false; if (!isCancelled()) { CropImageView cropImageView = mCropImageViewReference.get(); if (cropImageView != null) { completeCalled = true; cropImageView.onSetImageUriAsyncComplete(result); } } if (!completeCalled && result.bitmap != null) { // fast release of unused bitmap result.bitmap.recycle(); } } } //region: Inner class: Result /** * The result of BitmapLoadingWorkerTask async loading. */ public static final class Result { /** * The Android URI of the image to load */ public final Uri uri; /** * The loaded bitmap */ public final Bitmap bitmap; /** * The sample size used to load the given bitmap */ public final int loadSampleSize; /** * The degrees the image was rotated */ public final int degreesRotated; /** * The error that occurred during async bitmap loading. */ public final Exception error; Result(Uri uri, Bitmap bitmap, int loadSampleSize, int degreesRotated) { this.uri = uri; this.bitmap = bitmap; this.loadSampleSize = loadSampleSize; this.degreesRotated = degreesRotated; this.error = null; } Result(Uri uri, Exception error) { this.uri = uri; this.bitmap = null; this.loadSampleSize = 0; this.degreesRotated = 0; this.error = error; } } //endregion}
3)CropImageView.java
=====================
/* * Copyright 2013, Edmodo, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this work except in compliance with the License. * You may obtain a copy of the License in the LICENSE file, or 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. */ package com.eppico.widgets; import android.content.Context;import android.content.res.TypedArray;import android.graphics.Bitmap;import android.graphics.BitmapFactory;import android.graphics.Matrix;import android.graphics.Rect;import android.media.ExifInterface;import android.net.Uri;import android.os.Bundle;import android.os.Parcelable;import android.util.AttributeSet;import android.util.DisplayMetrics;import android.view.LayoutInflater;import android.view.View;import android.view.ViewGroup;import android.widget.FrameLayout;import android.widget.ImageView;import android.widget.ProgressBar;import com.eppico.R;import com.eppico.cropwindow.ImageViewUtil;import com.eppico.cropwindow.edge.Edge; import java.lang.ref.WeakReference; /** * Custom view that provides cropping capabilities to an image. */public class CropImageView extends FrameLayout { //region: Fields and Consts /** * Image view widget used to show the image for cropping. */ private final ImageView mImageView; /** * Overlay over the image view to show cropping UI. */ private final CropOverlayView mCropOverlayView; /** * Progress bar widget to show progress bar on async image loading and cropping. */ private final ProgressBar mProgressBar; private Bitmap mBitmap; private int mDegreesRotated = 0; private int mLayoutWidth; private int mLayoutHeight; private int mImageResource = 0; /** * if to show progress bar when image async loading/cropping is in progress.<br> * default: true, disable to provide custom progress bar UI. */ private boolean mShowProgressBar = true; /** * callback to be invoked when image async loading is complete */ private WeakReference<OnSetImageUriCompleteListener> mOnSetImageUriCompleteListener; /** * callback to be invoked when image async cropping is complete */ private WeakReference<OnGetCroppedImageCompleteListener> mOnGetCroppedImageCompleteListener; /** * The URI that the image was loaded from (if loaded from URI) */ private Uri mLoadedImageUri; /** * The sample size the image was loaded by if was loaded by URI */ private int mLoadedSampleSize = 1; /** * Task used to load bitmap async from UI thread */ private WeakReference<BitmapLoadingWorkerTask> mBitmapLoadingWorkerTask; /** * Task used to crop bitmap async from UI thread */ private WeakReference<BitmapCroppingWorkerTask> mBitmapCroppingWorkerTask; //endregion public CropImageView(Context context) { this(context, null); } public CropImageView(Context context, AttributeSet attrs) { super(context, attrs); int guidelines = Defaults.DEFAULT_GUIDELINES; boolean fixAspectRatio = Defaults.DEFAULT_FIXED_ASPECT_RATIO; int aspectRatioX = Defaults.DEFAULT_ASPECT_RATIO_X; int aspectRatioY = Defaults.DEFAULT_ASPECT_RATIO_Y; ImageView.ScaleType scaleType = Defaults.VALID_SCALE_TYPES[Defaults.DEFAULT_SCALE_TYPE_INDEX]; CropShape cropShape = CropShape.RECTANGLE; float snapRadius = Defaults.SNAP_RADIUS_DP; if (attrs != null) { TypedArray ta = context.obtainStyledAttributes(attrs, R.styleable.CropImageView, 0, 0); try { guidelines = ta.getInteger(R.styleable.CropImageView_guidelines, guidelines); fixAspectRatio = ta.getBoolean(R.styleable.CropImageView_fixAspectRatio, Defaults.DEFAULT_FIXED_ASPECT_RATIO); aspectRatioX = ta.getInteger(R.styleable.CropImageView_aspectRatioX, Defaults.DEFAULT_ASPECT_RATIO_X); aspectRatioY = ta.getInteger(R.styleable.CropImageView_aspectRatioY, Defaults.DEFAULT_ASPECT_RATIO_Y); scaleType = Defaults.VALID_SCALE_TYPES[ta.getInt(R.styleable.CropImageView_scaleType, Defaults.DEFAULT_SCALE_TYPE_INDEX)]; cropShape = Defaults.VALID_CROP_SHAPES[ta.getInt(R.styleable.CropImageView_cropShape, Defaults.DEFAULT_CROP_SHAPE_INDEX)]; snapRadius = ta.getFloat(R.styleable.CropImageView_snapRadius, snapRadius); mShowProgressBar = ta.getBoolean(R.styleable.CropImageView_showProgressBar, mShowProgressBar); } finally { ta.recycle(); } } LayoutInflater inflater = LayoutInflater.from(context); View v = inflater.inflate(R.layout.crop_image_view, this, true); mImageView = (ImageView) v.findViewById(R.id.ImageView_image); mImageView.setScaleType(scaleType); mCropOverlayView = (CropOverlayView) v.findViewById(R.id.CropOverlayView); mCropOverlayView.setInitialAttributeValues(guidelines, fixAspectRatio, aspectRatioX, aspectRatioY); mCropOverlayView.setCropShape(cropShape); mCropOverlayView.setSnapRadius(snapRadius); mCropOverlayView.setVisibility(mBitmap != null ? VISIBLE : INVISIBLE); mProgressBar = (ProgressBar) v.findViewById(R.id.CropProgressBar); setProgressBarVisibility(); } /** * Set the scale type of the image in the crop view */ public ImageView.ScaleType getScaleType() { return mImageView.getScaleType(); } /** * Set the scale type of the image in the crop view */ public void setScaleType(ImageView.ScaleType scaleType) { mImageView.setScaleType(scaleType); } /** * The shape of the cropping area - rectangle/circular. */ public CropShape getCropShape() { return mCropOverlayView.getCropShape(); } /** * The shape of the cropping area - rectangle/circular. */ public void setCropShape(CropShape cropShape) { mCropOverlayView.setCropShape(cropShape); } /** * Sets whether the aspect ratio is fixed or not; true fixes the aspect ratio, while * false allows it to be changed. * * @param fixAspectRatio Boolean that signals whether the aspect ratio should be * maintained. */ public void setFixedAspectRatio(boolean fixAspectRatio) { mCropOverlayView.setFixedAspectRatio(fixAspectRatio); } /** * Sets the guidelines for the CropOverlayView to be either on, off, or to show when * resizing the application. * * @param guidelines Integer that signals whether the guidelines should be on, off, or * only showing when resizing. */ public void setGuidelines(int guidelines) { mCropOverlayView.setGuidelines(guidelines); } /** * Sets the both the X and Y values of the aspectRatio. * * @param aspectRatioX int that specifies the new X value of the aspect ratio * @param aspectRatioY int that specifies the new Y value of the aspect ratio */ public void setAspectRatio(int aspectRatioX, int aspectRatioY) { mCropOverlayView.setAspectRatioX(aspectRatioX); mCropOverlayView.setAspectRatioY(aspectRatioY); } /** * An edge of the crop window will snap to the corresponding edge of a * specified bounding box when the crop window edge is less than or equal to * this distance (in pixels) away from the bounding box edge. (default: 3) */ public void setSnapRadius(float snapRadius) { if (snapRadius >= 0) { mCropOverlayView.setSnapRadius(snapRadius); } } /** * if to show progress bar when image async loading/cropping is in progress.<br> * default: true, disable to provide custom progress bar UI. */ public boolean isShowProgressBar() { return mShowProgressBar; } /** * if to show progress bar when image async loading/cropping is in progress.<br> * default: true, disable to provide custom progress bar UI. */ public void setShowProgressBar(boolean showProgressBar) { mShowProgressBar = showProgressBar; setProgressBarVisibility(); } /** * Returns the integer of the imageResource */ public int getImageResource() { return mImageResource; } /** * Get the URI of an image that was set by URI, null otherwise. */ public Uri getImageUri() { return mLoadedImageUri; } /** * Gets the crop window's position relative to the source Bitmap (not the image * displayed in the CropImageView). * * @return a RectF instance containing cropped area boundaries of the source Bitmap */ public Rect getActualCropRect() { if (mBitmap != null) { final Rect displayedImageRect = ImageViewUtil.getBitmapRect(mBitmap, mImageView, mImageView.getScaleType()); // Get the scale factor between the actual Bitmap dimensions and the displayed dimensions for width. final float actualImageWidth = mBitmap.getWidth(); final float displayedImageWidth = displayedImageRect.width(); final float scaleFactorWidth = actualImageWidth / displayedImageWidth; // Get the scale factor between the actual Bitmap dimensions and the displayed dimensions for height. final float actualImageHeight = mBitmap.getHeight(); final float displayedImageHeight = displayedImageRect.height(); final float scaleFactorHeight = actualImageHeight / displayedImageHeight; // Get crop window position relative to the displayed image. final float displayedCropLeft = Edge.LEFT.getCoordinate() - displayedImageRect.left; final float displayedCropTop = Edge.TOP.getCoordinate() - displayedImageRect.top; final float displayedCropWidth = Edge.getWidth(); final float displayedCropHeight = Edge.getHeight(); // Scale the crop window position to the actual size of the Bitmap. float actualCropLeft = displayedCropLeft * scaleFactorWidth; float actualCropTop = displayedCropTop * scaleFactorHeight; float actualCropRight = actualCropLeft + displayedCropWidth * scaleFactorWidth; float actualCropBottom = actualCropTop + displayedCropHeight * scaleFactorHeight; // Correct for floating point errors. Crop rect boundaries should not exceed the source Bitmap bounds. actualCropLeft = Math.max(0f, actualCropLeft); actualCropTop = Math.max(0f, actualCropTop); actualCropRight = Math.min(mBitmap.getWidth(), actualCropRight); actualCropBottom = Math.min(mBitmap.getHeight(), actualCropBottom); return new Rect((int) actualCropLeft, (int) actualCropTop, (int) actualCropRight, (int) actualCropBottom); } else { return null; } } /** * Gets the crop window's position relative to the source Bitmap (not the image * displayed in the CropImageView) and the original rotation. * * @return a RectF instance containing cropped area boundaries of the source Bitmap */ @SuppressWarnings("SuspiciousNameCombination") public Rect getActualCropRectNoRotation() { if (mBitmap != null) { Rect rect = getActualCropRect(); int rotateSide = mDegreesRotated / 90; if (rotateSide == 1) { rect.set(rect.top, mBitmap.getWidth() - rect.right, rect.bottom, mBitmap.getWidth() - rect.left); } else if (rotateSide == 2) { rect.set(mBitmap.getWidth() - rect.right, mBitmap.getHeight() - rect.bottom, mBitmap.getWidth() - rect.left, mBitmap.getHeight() - rect.top); } else if (rotateSide == 3) { rect.set(mBitmap.getHeight() - rect.bottom, rect.left, mBitmap.getHeight() - rect.top, rect.right); } rect.set(rect.left * mLoadedSampleSize, rect.top * mLoadedSampleSize, rect.right * mLoadedSampleSize, rect.bottom * mLoadedSampleSize); return rect; } else { return null; } } /** * Gets the cropped image based on the current crop window. * * @return a new Bitmap representing the cropped image */ public Bitmap getCroppedImage() { return getCroppedImage(0, 0); } /** * Gets the cropped image based on the current crop window.<br> * If image loaded from URI will use sample size to fit in the requested width and height down-sampling * if required - optimization to get best size to quality. * * @return a new Bitmap representing the cropped image */ public Bitmap getCroppedImage(int reqWidth, int reqHeight) { if (mBitmap != null) { if (mLoadedImageUri != null && mLoadedSampleSize > 1) { return ImageViewUtil.cropBitmap( getContext(), mLoadedImageUri, getActualCropRectNoRotation(), mDegreesRotated, reqWidth, reqHeight); } else { return ImageViewUtil.cropBitmap(mBitmap, getActualCropRect()); } } else { return null; } } /** * Gets the cropped circle image based on the current crop selection.<br> * Same as {@link #getCroppedImage()} (as the bitmap is rectangular by nature) but the pixels beyond the * oval crop will be transparent. * * @return a new Circular Bitmap representing the cropped image */ public Bitmap getCroppedOvalImage() { if (mBitmap != null) { Bitmap cropped = getCroppedImage(); return ImageViewUtil.toOvalBitmap(cropped); } else { return null; } } /** * Gets the cropped image based on the current crop window.<br> * The result will be invoked to listener set by {@link #setOnGetCroppedImageCompleteListener(OnGetCroppedImageCompleteListener)}. */ public void getCroppedImageAsync() { getCroppedImageAsync(CropShape.RECTANGLE, 0, 0); } /** * Gets the cropped image based on the current crop window.<br> * If image loaded from URI will use sample size to fit in the requested width and height down-sampling * if required - optimization to get best size to quality.<br> * The result will be invoked to listener set by {@link #setOnGetCroppedImageCompleteListener(OnGetCroppedImageCompleteListener)}. * * @param cropShape the shape to crop the image */ public void getCroppedImageAsync(CropShape cropShape, int reqWidth, int reqHeight) { if (mOnGetCroppedImageCompleteListener == null) { throw new IllegalArgumentException("OnGetCroppedImageCompleteListener is not set"); } BitmapCroppingWorkerTask currentTask = mBitmapCroppingWorkerTask != null ? mBitmapCroppingWorkerTask.get() : null; if (currentTask != null) { // cancel previous cropping currentTask.cancel(true); } mBitmapCroppingWorkerTask = mLoadedImageUri != null && mLoadedSampleSize > 1 ? new WeakReference<>(new BitmapCroppingWorkerTask(this, mLoadedImageUri, getActualCropRectNoRotation(), cropShape, mDegreesRotated, reqWidth, reqHeight)) : new WeakReference<>(new BitmapCroppingWorkerTask(this, mBitmap, getActualCropRect(), cropShape)); mBitmapCroppingWorkerTask.get().execute(); setProgressBarVisibility(); } /** * Set the callback to be invoked when image async loading ({@link #setImageUriAsync(Uri)}) * is complete (successful or failed). */ public void setOnSetImageUriCompleteListener(OnSetImageUriCompleteListener listener) { mOnSetImageUriCompleteListener = listener != null ? new WeakReference<>(listener) : null; } /** * Set the callback to be invoked when image async cropping ({@link #getCroppedImageAsync()}) * is complete (successful or failed). */ public void setOnGetCroppedImageCompleteListener(OnGetCroppedImageCompleteListener listener) { mOnGetCroppedImageCompleteListener = listener != null ? new WeakReference<>(listener) : null; } /** * Sets a Bitmap as the content of the CropImageView. * * @param bitmap the Bitmap to set */ public void setImageBitmap(Bitmap bitmap) { setBitmap(bitmap, true); } /** * Sets a Bitmap and initializes the image rotation according to the EXIT data.<br> * <br> * The EXIF can be retrieved by doing the following: * <code>ExifInterface exif = new ExifInterface(path);</code> * * @param bitmap the original bitmap to set; if null, this * @param exif the EXIF information about this bitmap; may be null */ public void setImageBitmap(Bitmap bitmap, ExifInterface exif) { if (bitmap != null && exif != null) { ImageViewUtil.RotateBitmapResult result = ImageViewUtil.rotateBitmapByExif(bitmap, exif); bitmap = result.bitmap; mDegreesRotated = result.degrees; } setBitmap(bitmap, true); } /** * Sets a Drawable as the content of the CropImageView. * * @param resId the drawable resource ID to set */ public void setImageResource(int resId) { if (resId != 0) { Bitmap bitmap = BitmapFactory.decodeResource(getResources(), resId); setBitmap(bitmap, true); mImageResource = resId; } } /** * Sets a bitmap loaded from the given Android URI as the content of the CropImageView.<br> * Can be used with URI from gallery or camera source.<br> * Will rotate the image by exif data.<br> * * @param uri the URI to load the image from * @deprecated Use {@link #setImageUriAsync(Uri)} for better async handling */ @Deprecated public void setImageUri(Uri uri) { if (uri != null) { DisplayMetrics metrics = getResources().getDisplayMetrics(); double densityAdj = metrics.density > 1 ? 1 / metrics.density : 1; //mScreenWidth = getActivity().getWindowManager().getDefaultDisplay().getWidth(); DisplayMetrics displayMetrics = getResources().getDisplayMetrics(); int width = displayMetrics.widthPixels; int height = width; // int width = (int) (metrics.widthPixels * densityAdj);// int height = (int) (metrics.heightPixels * densityAdj); ImageViewUtil.DecodeBitmapResult decodeResult = ImageViewUtil.decodeSampledBitmap(getContext(), uri, width, height); ImageViewUtil.RotateBitmapResult rotateResult = ImageViewUtil.rotateBitmapByExif(getContext(), decodeResult.bitmap, uri); setBitmap(rotateResult.bitmap, true); mLoadedImageUri = uri; mLoadedSampleSize = decodeResult.sampleSize; mDegreesRotated = rotateResult.degrees; } } /** * Sets a bitmap loaded from the given Android URI as the content of the CropImageView.<br> * Can be used with URI from gallery or camera source.<br> * Will rotate the image by exif data.<br> * * @param uri the URI to load the image from */ public void setImageUriAsync(Uri uri) { setImageUriAsync(uri, null); } /** * Clear the current image set for cropping. */ public void clearImage() { clearImage(true); } /** * Rotates image by the specified number of degrees clockwise. Cycles from 0 to 360 * degrees. * * @param degrees Integer specifying the number of degrees to rotate. */ public void rotateImage(int degrees) { if (mBitmap != null) { Matrix matrix = new Matrix(); matrix.postRotate(degrees); Bitmap bitmap = Bitmap.createBitmap(mBitmap, 0, 0, mBitmap.getWidth(), mBitmap.getHeight(), matrix, true); setBitmap(bitmap, false); mDegreesRotated += degrees; mDegreesRotated = mDegreesRotated % 360; } } //region: Private methods /** * Load image from given URI async using {@link BitmapLoadingWorkerTask}<br> * optionally rotate the loaded image given degrees, used for restore state. */ private void setImageUriAsync(Uri uri, Integer preSetRotation) { if (uri != null) { BitmapLoadingWorkerTask currentTask = mBitmapLoadingWorkerTask != null ? mBitmapLoadingWorkerTask.get() : null; if (currentTask != null) { // cancel previous loading (no check if the same URI because camera URI can be the same for different images) currentTask.cancel(true); } // either no existing task is working or we canceled it, need to load new URI clearImage(true); mBitmapLoadingWorkerTask = new WeakReference<>(new BitmapLoadingWorkerTask(this, uri, preSetRotation)); mBitmapLoadingWorkerTask.get().execute(); setProgressBarVisibility(); } } /** * On complete of the async bitmap loading by {@link #setImageUriAsync(Uri)} set the result * to the widget if still relevant and call listener if set. * * @param result the result of bitmap loading */ void onSetImageUriAsyncComplete(BitmapLoadingWorkerTask.Result result) { mBitmapLoadingWorkerTask = null; setProgressBarVisibility(); if (result.error == null) { setBitmap(result.bitmap, true); mLoadedImageUri = result.uri; mLoadedSampleSize = result.loadSampleSize; mDegreesRotated = result.degreesRotated; } OnSetImageUriCompleteListener listener = mOnSetImageUriCompleteListener != null ? mOnSetImageUriCompleteListener.get() : null; if (listener != null) { listener.onSetImageUriComplete(this, result.uri, result.error); } } /** * On complete of the async bitmap cropping by {@link #getCroppedImageAsync()} call listener if set. * * @param result the result of bitmap cropping */ void onGetImageCroppingAsyncComplete(BitmapCroppingWorkerTask.Result result) { mBitmapCroppingWorkerTask = null; setProgressBarVisibility(); OnGetCroppedImageCompleteListener listener = mOnGetCroppedImageCompleteListener != null ? mOnGetCroppedImageCompleteListener.get() : null; if (listener != null) { listener.onGetCroppedImageComplete(this, result.bitmap, result.error); } } /** * Set the given bitmap to be used in for cropping<br> * Optionally clear full if the bitmap is new, or partial clear if the bitmap has been manipulated. */ private void setBitmap(Bitmap bitmap, boolean clearFull) { if (mBitmap != bitmap) { clearImage(clearFull); mBitmap = bitmap; mImageView.setImageBitmap(mBitmap); if (mCropOverlayView != null) { mCropOverlayView.resetCropOverlayView(); mCropOverlayView.setVisibility(VISIBLE); } } } /** * Clear the current image set for cropping.<br> * Full clear will also clear the data of the set image like Uri or Resource id while partial clear * will only clear the bitmap and recycle if required. */ private void clearImage(boolean full) { // if we allocated the bitmap, release it as fast as possible if (mBitmap != null && (mImageResource > 0 || mLoadedImageUri != null)) { mBitmap.recycle(); mBitmap = null; } if (full) { // clean the loaded image flags for new image mImageResource = 0; mLoadedImageUri = null; mLoadedSampleSize = 1; mDegreesRotated = 0; mImageView.setImageBitmap(null); if (mCropOverlayView != null) { mCropOverlayView.setVisibility(INVISIBLE); } } } @Override public Parcelable onSaveInstanceState() { Bundle bundle = new Bundle(); bundle.putParcelable("instanceState", super.onSaveInstanceState()); bundle.putParcelable("LOADED_IMAGE_URI", mLoadedImageUri); bundle.putInt("LOADED_IMAGE_RESOURCE", mImageResource); if (mLoadedImageUri == null && mImageResource < 1) { bundle.putParcelable("SET_BITMAP", mBitmap); } if (mBitmapLoadingWorkerTask != null) { BitmapLoadingWorkerTask task = mBitmapLoadingWorkerTask.get(); if (task != null) { bundle.putParcelable("LOADING_IMAGE_URI", task.getUri()); } } bundle.putInt("DEGREES_ROTATED", mDegreesRotated); return bundle; } @Override public void onRestoreInstanceState(Parcelable state) { if (state instanceof Bundle) { Bundle bundle = (Bundle) state; Bitmap bitmap = null; Uri uri = bundle.getParcelable("LOADED_IMAGE_URI"); if (uri != null) { setImageUriAsync(uri, bundle.getInt("DEGREES_ROTATED")); } else { int resId = bundle.getInt("LOADED_IMAGE_RESOURCE"); if (resId > 0) { setImageResource(resId); } else { bitmap = bundle.getParcelable("SET_BITMAP"); if (bitmap != null) { setBitmap(bitmap, true); } else { uri = bundle.getParcelable("LOADING_IMAGE_URI"); if (uri != null) { setImageUriAsync(uri); } } } } mDegreesRotated = bundle.getInt("DEGREES_ROTATED"); if (mBitmap != null && bitmap == null) { // Fixes the rotation of the image when we reloaded it. int tmpRotated = mDegreesRotated; rotateImage(mDegreesRotated); mDegreesRotated = tmpRotated; } super.onRestoreInstanceState(bundle.getParcelable("instanceState")); } else { super.onRestoreInstanceState(state); } } @Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { if (mBitmap != null) { Rect bitmapRect = ImageViewUtil.getBitmapRect(mBitmap, this, mImageView.getScaleType()); mCropOverlayView.setBitmapRect(bitmapRect); } else { mCropOverlayView.setBitmapRect(Defaults.EMPTY_RECT); } } @Override protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) { super.onMeasure(widthMeasureSpec, heightMeasureSpec); int widthMode = MeasureSpec.getMode(widthMeasureSpec); int widthSize = MeasureSpec.getSize(widthMeasureSpec); int heightMode = MeasureSpec.getMode(heightMeasureSpec); int heightSize = MeasureSpec.getSize(heightMeasureSpec); if (mBitmap != null) { // Bypasses a baffling bug when used within a ScrollView, where heightSize is set to 0. if (heightSize == 0) { heightSize = mBitmap.getHeight(); } int desiredWidth; int desiredHeight; double viewToBitmapWidthRatio = Double.POSITIVE_INFINITY; double viewToBitmapHeightRatio = Double.POSITIVE_INFINITY; // Checks if either width or height needs to be fixed if (widthSize < mBitmap.getWidth()) { viewToBitmapWidthRatio = (double) widthSize / (double) mBitmap.getWidth(); } if (heightSize < mBitmap.getHeight()) { viewToBitmapHeightRatio = (double) heightSize / (double) mBitmap.getHeight(); } // If either needs to be fixed, choose smallest ratio and calculate from there if (viewToBitmapWidthRatio != Double.POSITIVE_INFINITY || viewToBitmapHeightRatio != Double.POSITIVE_INFINITY) { if (viewToBitmapWidthRatio <= viewToBitmapHeightRatio) { desiredWidth = widthSize; desiredHeight = (int) (mBitmap.getHeight() * viewToBitmapWidthRatio); } else { desiredHeight = heightSize; desiredWidth = (int) (mBitmap.getWidth() * viewToBitmapHeightRatio); } } else { // Otherwise, the picture is within frame layout bounds. Desired width is simply picture size desiredWidth = mBitmap.getWidth(); desiredHeight = mBitmap.getHeight(); } int width = getOnMeasureSpec(widthMode, widthSize, desiredWidth); int height = getOnMeasureSpec(heightMode, heightSize, desiredHeight); mLayoutWidth = width; mLayoutHeight = height; Rect bitmapRect = ImageViewUtil.getBitmapRect(mBitmap.getWidth(), mBitmap.getHeight(), mLayoutWidth, mLayoutHeight, mImageView.getScaleType()); mCropOverlayView.setBitmapRect(bitmapRect); // MUST CALL THIS setMeasuredDimension(mLayoutWidth, mLayoutHeight); } else { mCropOverlayView.setBitmapRect(Defaults.EMPTY_RECT); setMeasuredDimension(widthSize, heightSize); } } protected void onLayout(boolean changed, int l, int t, int r, int b) { super.onLayout(changed, l, t, r, b); if (mLayoutWidth > 0 && mLayoutHeight > 0) { // Gets original parameters, and creates the new parameters ViewGroup.LayoutParams origParams = this.getLayoutParams(); origParams.width = mLayoutWidth; origParams.height = mLayoutHeight; setLayoutParams(origParams); } } /** * Determines the specs for the onMeasure function. Calculates the width or height * depending on the mode. * * @param measureSpecMode The mode of the measured width or height. * @param measureSpecSize The size of the measured width or height. * @param desiredSize The desired size of the measured width or height. * @return The final size of the width or height. */ private static int getOnMeasureSpec(int measureSpecMode, int measureSpecSize, int desiredSize) { // Measure Width int spec; if (measureSpecMode == MeasureSpec.EXACTLY) { // Must be this size spec = measureSpecSize; } else if (measureSpecMode == MeasureSpec.AT_MOST) { // Can't be bigger than...; match_parent value spec = Math.min(desiredSize, measureSpecSize); } else { // Be whatever you want; wrap_content spec = desiredSize; } return spec; } /** * Set visibility of progress bar when async loading/cropping is in process and show is enabled. */ private void setProgressBarVisibility() { boolean visible = mShowProgressBar && ( (mBitmap == null && mBitmapLoadingWorkerTask != null) || (mBitmapCroppingWorkerTask != null)); mProgressBar.setVisibility(visible ? VISIBLE : INVISIBLE); } //endregion //region: Inner class: CropShape /** * The possible cropping area shape. */ public enum CropShape { RECTANGLE, OVAL } //endregion //region: Inner class: OnSetImageUriCompleteListener /** * Interface definition for a callback to be invoked when image async loading is complete. */ public interface OnSetImageUriCompleteListener { /** * Called when a crop image view has completed loading image for cropping.<br> * If loading failed error parameter will contain the error. * * @param view The crop image view that loading of image was complete. * @param uri the URI of the image that was loading * @param error if error occurred during loading will contain the error, otherwise null. */ void onSetImageUriComplete(CropImageView view, Uri uri, Exception error); } //endregion //region: Inner class: OnGetCroppedImageCompleteListener /** * Interface definition for a callback to be invoked when image async cropping is complete. */ public interface OnGetCroppedImageCompleteListener { /** * Called when a crop image view has completed loading image for cropping.<br> * If loading failed error parameter will contain the error. * * @param view The crop image view that cropping of image was complete. * @param bitmap the cropped image bitmap (null if failed) * @param error if error occurred during cropping will contain the error, otherwise null. */ void onGetCroppedImageComplete(CropImageView view, Bitmap bitmap, Exception error); } //endregion}4)CropOverlayView.java======================/* * Copyright 2013, Edmodo, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this work except in compliance with the License. * You may obtain a copy of the License in the LICENSE file, or 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. */ package com.eppico.widgets; import android.content.Context;import android.graphics.Canvas;import android.graphics.Paint;import android.graphics.Path;import android.graphics.Rect;import android.graphics.Region;import android.os.Build;import android.util.AttributeSet;import android.util.DisplayMetrics;import android.util.Pair;import android.util.TypedValue;import android.view.MotionEvent;import android.view.View;import com.eppico.cropwindow.AspectRatioUtil;import com.eppico.cropwindow.PaintUtil;import com.eppico.cropwindow.edge.Edge;import com.eppico.cropwindow.handle.Handle;import com.eppico.cropwindow.HandleUtil; /** * A custom View representing the crop window and the shaded background outside the crop window. */public class CropOverlayView extends View { //region: Fields and Consts /** * The Paint used to draw the white rectangle around the crop area. */ private Paint mBorderPaint; /** * The Paint used to draw the guidelines within the crop area when pressed. */ private Paint mGuidelinePaint; /** * The Paint used to draw the corners of the Border */ private Paint mCornerPaint; /** * The Paint used to darken the surrounding areas outside the crop area. */ private Paint mBackgroundPaint; /** * The bounding box around the Bitmap that we are cropping. */ private Rect mBitmapRect; // The radius of the touch zone (in pixels) around a given Handle. private float mHandleRadius; // An edge of the crop window will snap to the corresponding edge of a // specified bounding box when the crop window edge is less than or equal to // this distance (in pixels) away from the bounding box edge. private float mSnapRadius; // Holds the x and y offset between the exact touch location and the exact // handle location that is activated. There may be an offset because we // allow for some leeway (specified by mHandleRadius) in activating a // handle. However, we want to maintain these offset values while the handle // is being dragged so that the handle doesn't jump. private Pair<Float, Float> mTouchOffset; // The Handle that is currently pressed; null if no Handle is pressed. private Handle mPressedHandle; // Flag indicating if the crop area should always be a certain aspect ratio // (indicated by mTargetAspectRatio). private boolean mFixAspectRatio = Defaults.DEFAULT_FIXED_ASPECT_RATIO; // Floats to save the current aspect ratio of the image private int mAspectRatioX = Defaults.DEFAULT_ASPECT_RATIO_X; private int mAspectRatioY = Defaults.DEFAULT_ASPECT_RATIO_Y; // The aspect ratio that the crop area should maintain; this variable is // only used when mMaintainAspectRatio is true. private float mTargetAspectRatio = ((float) mAspectRatioX) / mAspectRatioY; /** * Instance variables for customizable attributes */ private int mGuidelines; /** * The shape of the cropping area - rectangle/circular. */ private CropImageView.CropShape mCropShape; // Whether the Crop View has been initialized for the first time private boolean initializedCropWindow = false; // Instance variables for the corner values private float mCornerExtension; private float mCornerOffset; private float mCornerLength; /** * Used to set back LayerType after changing to software. */ private Integer mOriginalLayerType; //endregion public CropOverlayView(Context context) { super(context); init(context); } public CropOverlayView(Context context, AttributeSet attrs) { super(context, attrs); init(context); } /** * Informs the CropOverlayView of the image's position relative to the * ImageView. This is necessary to call in order to draw the crop window. * * @param bitmapRect the image's bounding box */ public void setBitmapRect(Rect bitmapRect) { mBitmapRect = bitmapRect; initCropWindow(mBitmapRect); } /** * Resets the crop overlay view. */ public void resetCropOverlayView() { if (initializedCropWindow) { initCropWindow(mBitmapRect); invalidate(); } } /** * The shape of the cropping area - rectangle/circular. */ public CropImageView.CropShape getCropShape() { return mCropShape; } /** * The shape of the cropping area - rectangle/circular. */ public void setCropShape(CropImageView.CropShape cropShape) { if (mCropShape != cropShape) { mCropShape = cropShape; if (Build.VERSION.SDK_INT >= 11 && Build.VERSION.SDK_INT <= 17) { if (mCropShape == CropImageView.CropShape.OVAL) { mOriginalLayerType = getLayerType(); if (mOriginalLayerType != View.LAYER_TYPE_SOFTWARE) { // TURN off hardware acceleration setLayerType(View.LAYER_TYPE_SOFTWARE, null); } else { mOriginalLayerType = null; } } else if (mOriginalLayerType != null) { // return hardware acceleration back setLayerType(mOriginalLayerType, null); mOriginalLayerType = null; } } invalidate(); } } /** * Sets the guidelines for the CropOverlayView to be either on, off, or to * show when resizing the application. * * @param guidelines Integer that signals whether the guidelines should be * on, off, or only showing when resizing. */ public void setGuidelines(int guidelines) { if (guidelines < 0 || guidelines > 2) throw new IllegalArgumentException("Guideline value must be set between 0 and 2. See documentation."); else { mGuidelines = guidelines; if (initializedCropWindow) { initCropWindow(mBitmapRect); invalidate(); } } } /** * Sets whether the aspect ratio is fixed or not; true fixes the aspect * ratio, while false allows it to be changed. * * @param fixAspectRatio Boolean that signals whether the aspect ratio * should be maintained. */ public void setFixedAspectRatio(boolean fixAspectRatio) { mFixAspectRatio = fixAspectRatio; if (initializedCropWindow) { initCropWindow(mBitmapRect); invalidate(); } } /** * Sets the X value of the aspect ratio; is defaulted to 1. * * @param aspectRatioX int that specifies the new X value of the aspect * ratio */ public void setAspectRatioX(int aspectRatioX) { if (aspectRatioX <= 0) throw new IllegalArgumentException("Cannot set aspect ratio value to a number less than or equal to 0."); else { mAspectRatioX = aspectRatioX; mTargetAspectRatio = ((float) mAspectRatioX) / mAspectRatioY; if (initializedCropWindow) { initCropWindow(mBitmapRect); invalidate(); } } } /** * Sets the Y value of the aspect ratio; is defaulted to 1. * * @param aspectRatioY int that specifies the new Y value of the aspect * ratio */ public void setAspectRatioY(int aspectRatioY) { if (aspectRatioY <= 0) throw new IllegalArgumentException("Cannot set aspect ratio value to a number less than or equal to 0."); else { mAspectRatioY = aspectRatioY; mTargetAspectRatio = ((float) mAspectRatioX) / mAspectRatioY; if (initializedCropWindow) { initCropWindow(mBitmapRect); invalidate(); } } } /** * An edge of the crop window will snap to the corresponding edge of a * specified bounding box when the crop window edge is less than or equal to * this distance (in pixels) away from the bounding box edge. (default: 3) */ public void setSnapRadius(float snapRadius) { mSnapRadius = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, snapRadius, getResources().getDisplayMetrics()); } /** * Sets all initial values, but does not call initCropWindow to reset the * views. Used once at the very start to initialize the attributes. * * @param guidelines Integer that signals whether the guidelines should be * on, off, or only showing when resizing. * @param fixAspectRatio Boolean that signals whether the aspect ratio * should be maintained. * @param aspectRatioX float that specifies the new X value of the aspect * ratio * @param aspectRatioY float that specifies the new Y value of the aspect * ratio */ public void setInitialAttributeValues(int guidelines, boolean fixAspectRatio, int aspectRatioX, int aspectRatioY) { if (guidelines < 0 || guidelines > 2) throw new IllegalArgumentException("Guideline value must be set between 0 and 2. See documentation."); else mGuidelines = guidelines; mFixAspectRatio = fixAspectRatio; if (aspectRatioX <= 0) throw new IllegalArgumentException("Cannot set aspect ratio value to a number less than or equal to 0."); else { mAspectRatioX = aspectRatioX; mTargetAspectRatio = ((float) mAspectRatioX) / mAspectRatioY; } if (aspectRatioY <= 0) throw new IllegalArgumentException("Cannot set aspect ratio value to a number less than or equal to 0."); else { mAspectRatioY = aspectRatioY; mTargetAspectRatio = ((float) mAspectRatioX) / mAspectRatioY; } } //region: Private methods @Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { // Initialize the crop window here because we need the size of the view // to have been determined. initCropWindow(mBitmapRect); } @Override protected void onDraw(Canvas canvas) { super.onDraw(canvas); // Draw translucent background for the cropped area. drawBackground(canvas, mBitmapRect); if (showGuidelines()) { // Determines whether guidelines should be drawn or not if (mGuidelines == Defaults.GUIDELINES_ON) { drawRuleOfThirdsGuidelines(canvas); } else if (mGuidelines == Defaults.GUIDELINES_ON_TOUCH) { // Draw only when resizing if (mPressedHandle != null) drawRuleOfThirdsGuidelines(canvas); } } float w = mBorderPaint.getStrokeWidth(); float l = Edge.LEFT.getCoordinate() + w / 2; float t = Edge.TOP.getCoordinate() + w / 2; float r = Edge.RIGHT.getCoordinate() - w / 2; float b = Edge.BOTTOM.getCoordinate() - w / 2; if (mCropShape == CropImageView.CropShape.RECTANGLE) { // Draw rectangle crop window border. canvas.drawRect(l, t, r, b, mBorderPaint); drawCorners(canvas); } else { // Draw circular crop window border Defaults.EMPTY_RECT_F.set(l, t, r, b); canvas.drawOval(Defaults.EMPTY_RECT_F, mBorderPaint); } } @Override public boolean onTouchEvent(@SuppressWarnings("NullableProblems") MotionEvent event) { // If this View is not enabled, don't allow for touch interactions. if (!isEnabled()) { return false; } switch (event.getAction()) { case MotionEvent.ACTION_DOWN: onActionDown(event.getX(), event.getY()); return true; case MotionEvent.ACTION_UP: case MotionEvent.ACTION_CANCEL: getParent().requestDisallowInterceptTouchEvent(false); onActionUp(); return true; case MotionEvent.ACTION_MOVE: onActionMove(event.getX(), event.getY()); getParent().requestDisallowInterceptTouchEvent(true); return true; default: return false; } } private void init(Context context) { DisplayMetrics displayMetrics = context.getResources().getDisplayMetrics(); mHandleRadius = HandleUtil.getTargetRadius(context); mSnapRadius = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PT, Defaults.SNAP_RADIUS_DP, displayMetrics); mBorderPaint = PaintUtil.newBorderPaint(context); mGuidelinePaint = PaintUtil.newGuidelinePaint(); mBackgroundPaint = PaintUtil.newBackgroundPaint(); mCornerPaint = PaintUtil.newCornerPaint(context); // Sets the values for the corner sizes mCornerOffset = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, Defaults.DEFAULT_CORNER_OFFSET_DP, displayMetrics); mCornerExtension = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, Defaults.DEFAULT_CORNER_EXTENSION_DP, displayMetrics); mCornerLength = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, Defaults.DEFAULT_CORNER_LENGTH_DP, displayMetrics); // Sets guidelines to default until specified otherwise mGuidelines = Defaults.DEFAULT_GUIDELINES; } /** * Set the initial crop window size and position. This is dependent on the * size and position of the image being cropped. * * @param bitmapRect the bounding box around the image being cropped */ private void initCropWindow(Rect bitmapRect) { if (bitmapRect.width() == 0 || bitmapRect.height() == 0) { return; } // Tells the attribute functions the crop window has already been // initialized if (!initializedCropWindow) { initializedCropWindow = true; } if (mFixAspectRatio && (bitmapRect.left != 0 || bitmapRect.right != 0 || bitmapRect.top != 0 || bitmapRect.bottom != 0)) { // If the image aspect ratio is wider than the crop aspect ratio, // then the image height is the determining initial length. Else, // vice-versa. if (AspectRatioUtil.calculateAspectRatio(bitmapRect) > mTargetAspectRatio) { Edge.TOP.setCoordinate(bitmapRect.top); Edge.BOTTOM.setCoordinate(bitmapRect.bottom); float centerX = getWidth() / 2f; //dirty fix for wrong crop overlay aspect ratio when using fixed aspect ratio mTargetAspectRatio = (float) mAspectRatioX / mAspectRatioY; // Limits the aspect ratio to no less than 40 wide or 40 tall float cropWidth = Math.max(Edge.MIN_CROP_LENGTH_PX, AspectRatioUtil.calculateWidth(Edge.TOP.getCoordinate(), Edge.BOTTOM.getCoordinate(), mTargetAspectRatio)); // Create new TargetAspectRatio if the original one does not fit // the screen if (cropWidth == Edge.MIN_CROP_LENGTH_PX) { mTargetAspectRatio = (Edge.MIN_CROP_LENGTH_PX) / (Edge.BOTTOM.getCoordinate() - Edge.TOP.getCoordinate()); } float halfCropWidth = cropWidth / 2f; Edge.LEFT.setCoordinate(centerX - halfCropWidth); Edge.RIGHT.setCoordinate(centerX + halfCropWidth); } else { Edge.LEFT.setCoordinate(bitmapRect.left); Edge.RIGHT.setCoordinate(bitmapRect.right); float centerY = getHeight() / 2f; // Limits the aspect ratio to no less than 40 wide or 40 tall float cropHeight = Math.max(Edge.MIN_CROP_LENGTH_PX, AspectRatioUtil.calculateHeight(Edge.LEFT.getCoordinate(), Edge.RIGHT.getCoordinate(), mTargetAspectRatio)); // Create new TargetAspectRatio if the original one does not fit // the screen if (cropHeight == Edge.MIN_CROP_LENGTH_PX) { mTargetAspectRatio = (Edge.RIGHT.getCoordinate() - Edge.LEFT.getCoordinate()) / Edge.MIN_CROP_LENGTH_PX; } float halfCropHeight = cropHeight / 2f; Edge.TOP.setCoordinate(centerY - halfCropHeight); Edge.BOTTOM.setCoordinate(centerY + halfCropHeight); } } else { // ... do not fix aspect ratio... // Initialize crop window to have 10% padding w/ respect to image. float horizontalPadding = 0.1f * bitmapRect.width(); float verticalPadding = 0.1f * bitmapRect.height(); Edge.LEFT.setCoordinate(bitmapRect.left + horizontalPadding); Edge.TOP.setCoordinate(bitmapRect.top + verticalPadding); Edge.RIGHT.setCoordinate(bitmapRect.right - horizontalPadding); Edge.BOTTOM.setCoordinate(bitmapRect.bottom - verticalPadding); } } /** * Indicates whether the crop window is small enough that the guidelines * should be shown. Public because this function is also used to determine * if the center handle should be focused. * * @return boolean Whether the guidelines should be shown or not */ public static boolean showGuidelines() { if ((Math.abs(Edge.LEFT.getCoordinate() - Edge.RIGHT.getCoordinate()) < Defaults.DEFAULT_SHOW_GUIDELINES_LIMIT) || (Math.abs(Edge.TOP.getCoordinate() - Edge.BOTTOM.getCoordinate()) < Defaults.DEFAULT_SHOW_GUIDELINES_LIMIT)) { return false; } else { return true; } } private void drawRuleOfThirdsGuidelines(Canvas canvas) { float sw = mBorderPaint.getStrokeWidth(); float l = Edge.LEFT.getCoordinate() + sw; float t = Edge.TOP.getCoordinate() + sw; float r = Edge.RIGHT.getCoordinate() - sw; float b = Edge.BOTTOM.getCoordinate() - sw; float oneThirdCropWidth = Edge.getWidth() / 3; float oneThirdCropHeight = Edge.getHeight() / 3; if (mCropShape == CropImageView.CropShape.OVAL) { float w = Edge.getWidth() / 2 - sw; float h = Edge.getHeight() / 2 - sw; // Draw vertical guidelines. float x1 = l + oneThirdCropWidth; float x2 = r - oneThirdCropWidth; float yv = (float) (h * Math.sin(Math.acos((w - oneThirdCropWidth) / w))); canvas.drawLine(x1, t + h - yv, x1, b - h + yv, mGuidelinePaint); canvas.drawLine(x2, t + h - yv, x2, b - h + yv, mGuidelinePaint); // Draw horizontal guidelines. float y1 = t + oneThirdCropHeight; float y2 = b - oneThirdCropHeight; float xv = (float) (w * Math.cos(Math.asin((h - oneThirdCropHeight) / h))); canvas.drawLine(l + w - xv, y1, r - w + xv, y1, mGuidelinePaint); canvas.drawLine(l + w - xv, y2, r - w + xv, y2, mGuidelinePaint); } else { // Draw vertical guidelines. float x1 = l + oneThirdCropWidth; float x2 = r - oneThirdCropWidth; canvas.drawLine(x1, t, x1, b, mGuidelinePaint); canvas.drawLine(x2, t, x2, b, mGuidelinePaint); // Draw horizontal guidelines. float y1 = t + oneThirdCropHeight; float y2 = b - oneThirdCropHeight; canvas.drawLine(l, y1, r, y1, mGuidelinePaint); canvas.drawLine(l, y2, r, y2, mGuidelinePaint); } } private void drawBackground(Canvas canvas, Rect bitmapRect) { float l = Edge.LEFT.getCoordinate(); float t = Edge.TOP.getCoordinate(); float r = Edge.RIGHT.getCoordinate(); float b = Edge.BOTTOM.getCoordinate(); if (mCropShape == CropImageView.CropShape.RECTANGLE) { canvas.drawRect(bitmapRect.left, bitmapRect.top, bitmapRect.right, t, mBackgroundPaint); canvas.drawRect(bitmapRect.left, b, bitmapRect.right, bitmapRect.bottom, mBackgroundPaint); canvas.drawRect(bitmapRect.left, t, l, b, mBackgroundPaint); canvas.drawRect(r, t, bitmapRect.right, b, mBackgroundPaint); } else { Path circleSelectionPath = new Path(); if (Build.VERSION.SDK_INT >= 11 && Build.VERSION.SDK_INT <= 17 && mCropShape == CropImageView.CropShape.OVAL) { Defaults.EMPTY_RECT_F.set(l + 2, t + 2, r - 2, b - 2); } else { Defaults.EMPTY_RECT_F.set(l, t, r, b); } circleSelectionPath.addOval(Defaults.EMPTY_RECT_F, Path.Direction.CW); canvas.save(); canvas.clipPath(circleSelectionPath, Region.Op.XOR); canvas.drawRect(bitmapRect.left, bitmapRect.top, bitmapRect.right, bitmapRect.bottom, mBackgroundPaint); canvas.restore(); } } private void drawCorners(Canvas canvas) { float w = mBorderPaint.getStrokeWidth() * 1.5f + 1; float l = Edge.LEFT.getCoordinate() + w; float t = Edge.TOP.getCoordinate() + w; float r = Edge.RIGHT.getCoordinate() - w; float b = Edge.BOTTOM.getCoordinate() - w; // Top left canvas.drawLine(l - mCornerOffset, t - mCornerExtension, l - mCornerOffset, t + mCornerLength, mCornerPaint); canvas.drawLine(l, t - mCornerOffset, l + mCornerLength, t - mCornerOffset, mCornerPaint); // Top right canvas.drawLine(r + mCornerOffset, t - mCornerExtension, r + mCornerOffset, t + mCornerLength, mCornerPaint); canvas.drawLine(r, t - mCornerOffset, r - mCornerLength, t - mCornerOffset, mCornerPaint); // Bottom left canvas.drawLine(l - mCornerOffset, b + mCornerExtension, l - mCornerOffset, b - mCornerLength, mCornerPaint); canvas.drawLine(l, b + mCornerOffset, l + mCornerLength, b + mCornerOffset, mCornerPaint); // Bottom left canvas.drawLine(r + mCornerOffset, b + mCornerExtension, r + mCornerOffset, b - mCornerLength, mCornerPaint); canvas.drawLine(r, b + mCornerOffset, r - mCornerLength, b + mCornerOffset, mCornerPaint); } /** * Handles a {@link MotionEvent#ACTION_DOWN} event. * * @param x the x-coordinate of the down action * @param y the y-coordinate of the down action */ private void onActionDown(float x, float y) { float left = Edge.LEFT.getCoordinate(); float top = Edge.TOP.getCoordinate(); float right = Edge.RIGHT.getCoordinate(); float bottom = Edge.BOTTOM.getCoordinate(); mPressedHandle = HandleUtil.getPressedHandle(x, y, left, top, right, bottom, mHandleRadius, mCropShape); if (mPressedHandle == null) { return; } // Calculate the offset of the touch point from the precise location // of the handle. Save these values in a member variable since we want // to maintain this offset as we drag the handle. mTouchOffset = HandleUtil.getOffset(mPressedHandle, x, y, left, top, right, bottom); invalidate(); } /** * Handles a {@link MotionEvent#ACTION_UP} or * {@link MotionEvent#ACTION_CANCEL} event. */ private void onActionUp() { if (mPressedHandle == null) { return; } mPressedHandle = null; invalidate(); } /** * Handles a {@link MotionEvent#ACTION_MOVE} event. * * @param x the x-coordinate of the move event * @param y the y-coordinate of the move event */ private void onActionMove(float x, float y) { if (mPressedHandle == null) { return; } // Adjust the coordinates for the finger position's offset (i.e. the // distance from the initial touch to the precise handle location). // We want to maintain the initial touch's distance to the pressed // handle so that the crop window size does not "jump". x += mTouchOffset.first; y += mTouchOffset.second; // Calculate the new crop window size/position. if (mFixAspectRatio) { mPressedHandle.updateCropWindow(x, y, mTargetAspectRatio, mBitmapRect, mSnapRadius); } else { mPressedHandle.updateCropWindow(x, y, mBitmapRect, mSnapRadius); } invalidate(); } //endregion}5)CustomFont.java===================package com.eppico.widgets; import android.content.Context;import android.graphics.Typeface;import android.util.AttributeSet;import android.widget.TextView; public class CustomFont extends TextView { private Context c; public CustomFont(Context c) { super(c); this.c = c; Typeface tfs = Typeface.createFromAsset(c.getAssets(), "Roboto-Regular_3.ttf"); setTypeface(tfs); } public CustomFont(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); this.c = context; Typeface tfs = Typeface.createFromAsset(c.getAssets(), "Roboto-Regular_3.ttf"); setTypeface(tfs); } public CustomFont(Context context, AttributeSet attrs) { super(context, attrs); this.c = context; Typeface tfs = Typeface.createFromAsset(c.getAssets(), "Roboto-Regular_3.ttf"); setTypeface(tfs); } }6)Defaults.java===================// "Therefore those skilled at the unorthodox// are infinite as heaven and earth,// inexhaustible as the great rivers.// When they come to an end,// they begin again,// like the days and months;// they die and are reborn,// like the four seasons."//// - Sun Tsu,// "The Art of War" package com.eppico.widgets; import android.graphics.Rect;import android.graphics.RectF;import android.widget.ImageView; import com.eppico.cropwindow.PaintUtil; /** * Defaults used in the library. */class Defaults { public static final Rect EMPTY_RECT = new Rect(); public static final RectF EMPTY_RECT_F = new RectF(); // Sets the default image guidelines to show when resizing public static final int DEFAULT_GUIDELINES = 1; public static final boolean DEFAULT_FIXED_ASPECT_RATIO = false; public static final int DEFAULT_ASPECT_RATIO_X = 1; public static final int DEFAULT_ASPECT_RATIO_Y = 1; public static final int DEFAULT_SCALE_TYPE_INDEX = 0; public static final int DEFAULT_CROP_SHAPE_INDEX = 0; public static final float SNAP_RADIUS_DP = 3; public static final float DEFAULT_SHOW_GUIDELINES_LIMIT = 100; // Gets default values from PaintUtil, sets a bunch of values such that the // corners will draw correctly public static final float DEFAULT_CORNER_THICKNESS_DP = PaintUtil.getCornerThickness(); public static final float DEFAULT_LINE_THICKNESS_DP = PaintUtil.getLineThickness(); public static final float DEFAULT_CORNER_OFFSET_DP = (DEFAULT_CORNER_THICKNESS_DP / 2) - (DEFAULT_LINE_THICKNESS_DP / 2); public static final float DEFAULT_CORNER_EXTENSION_DP = DEFAULT_CORNER_THICKNESS_DP / 2 + DEFAULT_CORNER_OFFSET_DP; public static final float DEFAULT_CORNER_LENGTH_DP = 15; public static final int GUIDELINES_ON_TOUCH = 1; public static final int GUIDELINES_ON = 2; public static final ImageView.ScaleType[] VALID_SCALE_TYPES = new ImageView.ScaleType[]{ImageView.ScaleType.CENTER_INSIDE, ImageView.ScaleType.FIT_CENTER}; public static final CropImageView.CropShape[] VALID_CROP_SHAPES = new CropImageView.CropShape[]{CropImageView.CropShape.RECTANGLE, CropImageView.CropShape.OVAL};}7)EasyDialog.java====================package com.eppico.widgets; import android.animation.Animator;import android.animation.AnimatorSet;import android.animation.ObjectAnimator;import android.annotation.SuppressLint;import android.app.Activity;import android.app.Dialog;import android.content.Context;import android.content.DialogInterface;import android.graphics.Color;import android.graphics.drawable.GradientDrawable;import android.graphics.drawable.LayerDrawable;import android.graphics.drawable.RotateDrawable;import android.os.Build;import android.util.DisplayMetrics;import android.view.LayoutInflater;import android.view.MotionEvent;import android.view.View;import android.view.ViewGroup;import android.view.ViewTreeObserver;import android.widget.ImageView;import android.widget.LinearLayout;import android.widget.RelativeLayout;import android.widget.Toast; import com.eppico.R; import java.util.ArrayList;import java.util.List; /** * Created by michael on 15/4/15. */public class EasyDialog { private Context context; /** * 内容在三角形上面 */ public static final int GRAVITY_TOP = 0; /** * 内容在三角形下面 */ public static final int GRAVITY_BOTTOM = 1; /** * 内容在三角形左面 */ public static final int GRAVITY_LEFT = 2; /** * 内容在三角形右面 */ public static final int GRAVITY_RIGHT = 3; /** * 对话框本身 */ private Dialog dialog; /** * 坐标 */ private int[] location; /** * 提醒框位置 */ private int gravity; /** * 外面传递进来的View */ private View contentView; /** * 三角形 */ private ImageView ivTriangle; /** * 用来放外面传递进来的View */ private LinearLayout llContent; /** * 触摸外面，是否关闭对话框 */ private boolean touchOutsideDismiss; /** * 提示框所在的容器 */ private RelativeLayout rlOutsideBackground; public EasyDialog(Context context) { initDialog(context); } private void initDialog(final Context context) { this.context = context; LayoutInflater layoutInflater = ((Activity) context).getLayoutInflater(); View dialogView = layoutInflater.inflate(R.layout.layout_dialog, null); ViewTreeObserver viewTreeObserver = dialogView.getViewTreeObserver(); viewTreeObserver.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() { @Override public void onGlobalLayout() { //当View可以获取宽高的时候，设置view的位置 relocation(location); } }); rlOutsideBackground = (RelativeLayout) dialogView.findViewById(R.id.rlOutsideBackground); setTouchOutsideDismiss(true); ivTriangle = (ImageView) dialogView.findViewById(R.id.ivTriangle); llContent = (LinearLayout) dialogView.findViewById(R.id.llContent); dialog = new Dialog(context, isFullScreen() ? android.R.style.Theme_Translucent_NoTitleBar_Fullscreen : android.R.style.Theme_Translucent_NoTitleBar); dialog.setContentView(dialogView); dialog.setOnDismissListener(new DialogInterface.OnDismissListener() { @Override public void onDismiss(DialogInterface dialog) { if (onEasyDialogDismissed != null) { onEasyDialogDismissed.onDismissed(); } } }); dialog.setOnShowListener(new DialogInterface.OnShowListener() { @Override public void onShow(DialogInterface dialog) { if (onEasyDialogShow != null) { onEasyDialogShow.onShow(); } } }); animatorSetForDialogShow = new AnimatorSet(); animatorSetForDialogDismiss = new AnimatorSet(); objectAnimatorsForDialogShow = new ArrayList<>(); objectAnimatorsForDialogDismiss = new ArrayList<>(); ini(); } final View.OnTouchListener outsideBackgroundListener = new View.OnTouchListener() { @Override public boolean onTouch(View v, MotionEvent event) { if (touchOutsideDismiss && dialog != null) { onDialogDismiss(); } return false; } }; /** * The Dialog instance */ public Dialog getDialog() { return dialog; } /** * 初始化默认值 */ private void ini() { this.setLocation(new int[]{0, 0}) .setGravity(GRAVITY_BOTTOM) .setTouchOutsideDismiss(true) .setOutsideColor(Color.TRANSPARENT) .setBackgroundColor(Color.BLUE) .setMatchParent(true) .setMarginLeftAndRight(24, 24); } /** * 设置提示框中要显示的内容 */ public EasyDialog setLayout(View layout) { if (layout != null) { this.contentView = layout; } return this; } /** * 设置提示框中要显示的内容的布局Id */ public EasyDialog setLayoutResourceId(int layoutResourceId) { View view = ((Activity) context).getLayoutInflater().inflate(layoutResourceId, null); setLayout(view); return this; } /** * 设置三角形所在的位置 */ public EasyDialog setLocation(int[] location) { this.location = location; return this; } /** * 设置三角形所在的位置 * location.x坐标值为attachedView所在屏幕位置的中心 * location.y坐标值依据当前的gravity，如果gravity是top，则为控件上方的y值，如果是bottom，则为控件的下方的y值 * * @param attachedView 在哪个View显示提示信息 */ public EasyDialog setLocationByAttachedView(View attachedView) { if (attachedView != null) { this.attachedView = attachedView; int[] attachedViewLocation = new int[2]; attachedView.getLocationOnScreen(attachedViewLocation); switch (gravity) { case GRAVITY_BOTTOM: attachedViewLocation[0] += attachedView.getWidth() / 2; attachedViewLocation[1] += attachedView.getHeight(); break; case GRAVITY_TOP: attachedViewLocation[0] += attachedView.getWidth() / 2; break; case GRAVITY_LEFT: attachedViewLocation[1] += attachedView.getHeight() / 2; break; case GRAVITY_RIGHT: attachedViewLocation[0] += attachedView.getWidth(); attachedViewLocation[1] += attachedView.getHeight() / 2; } setLocation(attachedViewLocation); } return this; } /** * 对话框所依附的View */ private View attachedView = null; public View getAttachedView() { return this.attachedView; } /** * 设置显示的内容在上方还是下方，如果设置错误，默认是在下方 */ public EasyDialog setGravity(int gravity) { if (gravity != GRAVITY_BOTTOM && gravity != GRAVITY_TOP && gravity != GRAVITY_LEFT && gravity != GRAVITY_RIGHT) { gravity = GRAVITY_BOTTOM; } this.gravity = gravity; switch (this.gravity) { case GRAVITY_BOTTOM: ivTriangle.setBackgroundResource(R.drawable.triangle_bottom); break; case GRAVITY_TOP: ivTriangle.setBackgroundResource(R.drawable.triangle_top); break; case GRAVITY_LEFT: ivTriangle.setBackgroundResource(R.drawable.triangle_left); break; case GRAVITY_RIGHT: ivTriangle.setBackgroundResource(R.drawable.triangle_right); break; } llContent.setBackgroundResource(R.drawable.round_corner_bg); if (attachedView != null)//如果用户调用setGravity()之前就调用过setLocationByAttachedView，需要再调用一次setLocationByAttachedView { this.setLocationByAttachedView(attachedView); } this.setBackgroundColor(backgroundColor); return this; } /** * 设置是否填充屏幕，如果不填充就适应布局内容的宽度，显示内容的位置会尽量随着三角形的位置居中 */ public EasyDialog setMatchParent(boolean matchParent) { ViewGroup.LayoutParams layoutParams = llContent.getLayoutParams(); layoutParams.width = matchParent ? ViewGroup.LayoutParams.MATCH_PARENT : ViewGroup.LayoutParams.WRAP_CONTENT; llContent.setLayoutParams(layoutParams); return this; } /** * 距离屏幕左右的边距 */ public EasyDialog setMarginLeftAndRight(int left, int right) { RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) llContent.getLayoutParams(); layoutParams.setMargins(left, 0, right, 0); llContent.setLayoutParams(layoutParams); return this; } public EasyDialog setMarginTopAndBottom(int top, int bottom) { RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) llContent.getLayoutParams(); layoutParams.setMargins(0, top, 0, bottom); llContent.setLayoutParams(layoutParams); return this; } /** * 设置触摸对话框外面，对话框是否消失 */ public EasyDialog setTouchOutsideDismiss(boolean touchOutsideDismiss) { this.touchOutsideDismiss = touchOutsideDismiss; if (touchOutsideDismiss) { rlOutsideBackground.setOnTouchListener(outsideBackgroundListener); } else { rlOutsideBackground.setOnTouchListener(null); } return this; } /** * 设置提醒框外部区域的颜色 */ public EasyDialog setOutsideColor(int color) { rlOutsideBackground.setBackgroundColor(color); return this; } private int backgroundColor; /** * 设置对话框的颜色 * 三角形的图片是layer-list里面嵌套一个RotateDrawable，在设置颜色的时候需要特别处理 * http://stackoverflow.com/questions/24492000/set-color-of-triangle-on-run-time * http://stackoverflow.com/questions/16636412/change-shape-solid-color-at-runtime-inside-drawable-xml-used-as-background */ public EasyDialog setBackgroundColor(int color) { backgroundColor = color; LayerDrawable drawableTriangle = (LayerDrawable) ivTriangle.getBackground(); GradientDrawable shapeTriangle = (GradientDrawable) (((RotateDrawable) drawableTriangle.findDrawableByLayerId(R.id.shape_id)).getDrawable()); if (shapeTriangle != null) { shapeTriangle.setColor(color); } else { Toast.makeText(context, "shape is null", Toast.LENGTH_SHORT).show(); } GradientDrawable drawableRound = (GradientDrawable) llContent.getBackground(); if (drawableRound != null) { drawableRound.setColor(color); } return this; } /** * 显示提示框 */ public EasyDialog show() { if (dialog != null) { if (contentView == null) { throw new RuntimeException("您是否未调用setLayout()或者setLayoutResourceId()方法来设置要显示的内容呢？"); } if (llContent.getChildCount() > 0) { llContent.removeAllViews(); } llContent.addView(contentView); dialog.show(); onDialogShowing(); } return this; } /** * 显示对话框的View的parent，如果想自己写动画，可以获取这个实例来写动画 */ public View getTipViewInstance() { return rlOutsideBackground.findViewById(R.id.rlParentForAnimate); } /** * 横向 */ public static final int DIRECTION_X = 0; /** * 纵向 */ public static final int DIRECTION_Y = 1; /** * 水平动画 * * @param direction 动画的方向 * @param duration 动画执行的时间长度 * @param values 动画移动的位置 */ public EasyDialog setAnimationTranslationShow(int direction, int duration, float... values) { return setAnimationTranslation(true, direction, duration, values); } /** * 水平动画 * * @param direction 动画的方向 * @param duration 动画执行的时间长度 * @param values 动画移动的位置 */ public EasyDialog setAnimationTranslationDismiss(int direction, int duration, float... values) { return setAnimationTranslation(false, direction, duration, values); } private EasyDialog setAnimationTranslation(boolean isShow, int direction, int duration, float... values) { if (direction != DIRECTION_X && direction != DIRECTION_Y) { direction = DIRECTION_X; } String propertyName = ""; switch (direction) { case DIRECTION_X: propertyName = "translationX"; break; case DIRECTION_Y: propertyName = "translationY"; break; } ObjectAnimator animator = ObjectAnimator.ofFloat(rlOutsideBackground.findViewById(R.id.rlParentForAnimate), propertyName, values) .setDuration(duration); if (isShow) { objectAnimatorsForDialogShow.add(animator); } else { objectAnimatorsForDialogDismiss.add(animator); } return this; } /** * 对话框出现时候的渐变动画 * * @param duration 动画执行的时间长度 * @param values 动画移动的位置 */ public EasyDialog setAnimationAlphaShow(int duration, float... values) { return setAnimationAlpha(true, duration, values); } /** * 对话框消失时候的渐变动画 * * @param duration 动画执行的时间长度 * @param values 动画移动的位置 */ public EasyDialog setAnimationAlphaDismiss(int duration, float... values) { return setAnimationAlpha(false, duration, values); } private EasyDialog setAnimationAlpha(boolean isShow, int duration, float... values) { ObjectAnimator animator = ObjectAnimator.ofFloat(rlOutsideBackground.findViewById(R.id.rlParentForAnimate), "alpha", values).setDuration(duration); if (isShow) { objectAnimatorsForDialogShow.add(animator); } else { objectAnimatorsForDialogDismiss.add(animator); } return this; } private AnimatorSet animatorSetForDialogShow; private AnimatorSet animatorSetForDialogDismiss; private List<Animator> objectAnimatorsForDialogShow; private List<Animator> objectAnimatorsForDialogDismiss; private void onDialogShowing() { if (animatorSetForDialogShow != null && objectAnimatorsForDialogShow != null && objectAnimatorsForDialogShow.size() > 0) { animatorSetForDialogShow.playTogether(objectAnimatorsForDialogShow); animatorSetForDialogShow.start(); } //TODO 缩放的动画效果不好，不能从控件所在的位置开始缩放// ObjectAnimator.ofFloat(rlOutsideBackground.findViewById(R.id.rlParentForAnimate), "scaleX", 0.3f, 1.0f).setDuration(500).start();// ObjectAnimator.ofFloat(rlOutsideBackground.findViewById(R.id.rlParentForAnimate), "scaleY", 0.3f, 1.0f).setDuration(500).start(); } @SuppressLint("NewApi") private void onDialogDismiss() { if (animatorSetForDialogDismiss.isRunning()) { return; } if (animatorSetForDialogDismiss != null && objectAnimatorsForDialogDismiss != null && objectAnimatorsForDialogDismiss.size() > 0) { animatorSetForDialogDismiss.playTogether(objectAnimatorsForDialogDismiss); animatorSetForDialogDismiss.start(); animatorSetForDialogDismiss.addListener(new Animator.AnimatorListener() { @Override public void onAnimationStart(Animator animation) { } @Override public void onAnimationEnd(Animator animation) { //这里有可能会有bug，当Dialog所依赖的Activity关闭的时候，如果这个时候，用户关闭对话框，由于对话框的动画关闭需要时间，当动画执行完毕后，对话框所依赖的Activity已经被销毁了，执行dismiss()就会报错 if (context != null && context instanceof Activity) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) { if (!((Activity) context).isDestroyed()) { dialog.dismiss(); } } else { try { dialog.dismiss(); } catch (final IllegalArgumentException e) { } catch (final Exception e) { } finally { dialog = null; } } } } @Override public void onAnimationCancel(Animator animation) { } @Override public void onAnimationRepeat(Animator animation) { } }); } else { dialog.dismiss(); } } /** * 关闭提示框 */ public void dismiss() { if (dialog != null && dialog.isShowing()) { onDialogDismiss(); } } /** * 根据x，y，重新设置控件的位置 * 因为setX setY为0的时候，都是在状态栏以下的，所以app不是全屏的话，需要扣掉状态栏的高度 */ private void relocation(int[] location) { float statusBarHeight = isFullScreen() ? 0.0f : getStatusBarHeight(); ivTriangle.setX(location[0] - ivTriangle.getWidth() / 2); ivTriangle.setY(location[1] - ivTriangle.getHeight() / 2 - statusBarHeight); switch (gravity) { case GRAVITY_BOTTOM: llContent.setY(location[1] - ivTriangle.getHeight() / 2 - statusBarHeight + ivTriangle.getHeight()); break; case GRAVITY_TOP: llContent.setY(location[1] - llContent.getHeight() - statusBarHeight - ivTriangle.getHeight() / 2); break; case GRAVITY_LEFT: llContent.setX(location[0] - llContent.getWidth() - ivTriangle.getWidth() / 2); break; case GRAVITY_RIGHT: llContent.setX(location[0] + ivTriangle.getWidth() / 2); break; } RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) llContent.getLayoutParams(); switch (gravity) { case GRAVITY_BOTTOM: case GRAVITY_TOP: int triangleCenterX = (int) (ivTriangle.getX() + ivTriangle.getWidth() / 2); int contentWidth = llContent.getWidth(); int rightMargin = getScreenWidth() - triangleCenterX; int leftMargin = getScreenWidth() - rightMargin; int availableLeftMargin = leftMargin - layoutParams.leftMargin; int availableRightMargin = rightMargin - layoutParams.rightMargin; int x = 0; if (contentWidth / 2 <= availableLeftMargin && contentWidth / 2 <= availableRightMargin) { x = triangleCenterX - contentWidth / 2; } else { if (availableLeftMargin <= availableRightMargin) { x = layoutParams.leftMargin; } else { x = getScreenWidth() - (contentWidth + layoutParams.rightMargin); } } llContent.setX(x); break; case GRAVITY_LEFT: case GRAVITY_RIGHT: int triangleCenterY = (int) (ivTriangle.getY() + ivTriangle.getHeight() / 2); int contentHeight = llContent.getHeight(); int topMargin = triangleCenterY; int bottomMargin = getScreenHeight() - topMargin; int availableTopMargin = topMargin - layoutParams.topMargin; int availableBottomMargin = bottomMargin - layoutParams.bottomMargin; int y = 0; if (contentHeight / 2 <= availableTopMargin && contentHeight / 2 <= availableBottomMargin) { y = triangleCenterY - contentHeight / 2; } else { if (availableTopMargin <= availableBottomMargin) { y = layoutParams.topMargin; } else { y = getScreenHeight() - (contentHeight + layoutParams.topMargin); } } llContent.setY(y); break; } } /** * 获取屏幕的宽度 */ private int getScreenWidth() { DisplayMetrics metrics = context.getResources().getDisplayMetrics(); return metrics.widthPixels; } private int getScreenHeight() { int statusBarHeight = isFullScreen() ? 0 : getStatusBarHeight(); DisplayMetrics metrics = context.getResources().getDisplayMetrics(); return metrics.heightPixels - statusBarHeight; } /** * 获取状态栏的高度 */ private int getStatusBarHeight() { int result = 0; int resourceId = context.getResources().getIdentifier("status_bar_height", "dimen", "android"); if (resourceId > 0) { result = context.getResources().getDimensionPixelSize(resourceId); } return result; } /** * 判断下当前要显示对话框的Activity是否是全屏 */ public boolean isFullScreen() { int flg = ((Activity) context).getWindow().getAttributes().flags; boolean flag = false; if ((flg & 1024) == 1024) { flag = true; } return flag; } /** * 设置是否可以按返回按钮取消 */ public EasyDialog setCancelable(boolean cancelable) { dialog.setCancelable(cancelable); return this; } private OnEasyDialogDismissed onEasyDialogDismissed; public EasyDialog setOnEasyDialogDismissed(OnEasyDialogDismissed onEasyDialogDismissed) { this.onEasyDialogDismissed = onEasyDialogDismissed; return this; } /** * Dialog is dismissed */ public interface OnEasyDialogDismissed { public void onDismissed(); } private OnEasyDialogShow onEasyDialogShow; public EasyDialog setOnEasyDialogShow(OnEasyDialogShow onEasyDialogShow) { this.onEasyDialogShow = onEasyDialogShow; return this; } /** * Dialog is showing */ public interface OnEasyDialogShow { public void onShow(); } }8)EdittextRobotoRegular.java==============================package com.eppico.widgets; import android.content.Context;import android.content.res.TypedArray;import android.graphics.Typeface;import android.text.InputFilter;import android.util.AttributeSet;import android.widget.EditText; import com.eppico.R; public class EdittextRobotoRegular extends EditText { Context context; boolean disableEmoticons=true; // Initial disable emoticons public EdittextRobotoRegular(Context context) { this(context,null); /*super(context); this.context = context; init(context);*/ } public EdittextRobotoRegular(Context context, AttributeSet attrs) { this(context,attrs,android.R.attr.editTextStyle); /*super(context, attrs); this.context = context; init(context);*/ } public EdittextRobotoRegular(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); this.context = context; init(context,attrs); } private void init(Context context,AttributeSet attrs) { TypedArray attr = context.obtainStyledAttributes(attrs, R.styleable.MyEditText, 0, 0); this.disableEmoticons=attr.getBoolean(R.styleable.MyEditText_disableEmoticons, disableEmoticons); //this.disableEmoticons=attr.getBoolean(R.styleable.MyEdittext_disableEmoticons, disableEmoticons); Typeface tf = Typeface.createFromAsset(getContext().getAssets(), "Roboto-Regular_3.ttf"); setTypeface(tf); /*InputFilter[] filterArray = new InputFilter[2]; filterArray[0] = new InputFilter.LengthFilter(maxLength); filterArray[1] = new EmojiExcludeFilter(context); setFilters(filterArray);*/ if(disableEmoticons) { InputFilter curFilters[] = getFilters(); if (curFilters != null) { InputFilter newFilters[] = new InputFilter[curFilters.length + 1]; System.arraycopy(curFilters, 0, newFilters, 0, curFilters.length); newFilters[curFilters.length] = new EmojiExcludeFilter(context); setFilters(newFilters); } } } /** Default it is enabled * @param disableEmoticons true: Disable emoticons, false: enable emoticons * */ public void setDisableEmoticons(boolean disableEmoticons) { this.disableEmoticons=disableEmoticons; invalidate(); } /*private class EmojiExcludeFilter implements InputFilter { @Override public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) { for (int i = start; i < end; i++) { int type = Character.getType(source.charAt(i)); if (type == Character.SURROGATE || type == Character.OTHER_SYMBOL) { //Show message only one time if(firstTime) { firstTime=false; ToastHelper.getInstance().showToast(context,context.getString(R.string.msgEmoticonsNotAllowed)); } return ""; } } return null; } }*/}9)EmojiExcludeFilter.java==========================package com.eppico.widgets; import android.content.Context;import android.text.InputFilter;import android.text.Spanned;import android.widget.Toast; import com.eppico.R;import com.eppico.utility.ToastHelper; public class EmojiExcludeFilter implements InputFilter { Context context; private boolean firstTime=true; public EmojiExcludeFilter(Context context) { this.context= context; } @Override public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) { for (int i = start; i < end; i++) { int type = Character.getType(source.charAt(i)); if (type == Character.SURROGATE || type == Character.OTHER_SYMBOL) { //Show message only one time if (firstTime) { firstTime = false; ToastHelper.getInstance().showToast(context, context.getString(R.string.msgEmoticonsNotAllowed), Toast.LENGTH_LONG); } return ""; } } return null; } }10)MyEditText.java=======================package com.eppico.widgets; import android.content.Context;import android.content.res.TypedArray;import android.graphics.Typeface;import android.text.InputFilter;import android.util.AttributeSet;import android.widget.EditText; import com.eppico.R; public class MyEditText extends EditText { Context context; boolean disableEmoticons=true; // Initial disable emoticons int fontType; String fontNames[]; public MyEditText(Context context) { this(context,null); } public MyEditText(Context context, AttributeSet attrs) { this(context,attrs,android.R.attr.editTextStyle); } public MyEditText(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); this.context = context; fontNames=context.getResources().getStringArray(R.array.fontNames); init(context,attrs); } private void init(Context context,AttributeSet attrs) { TypedArray attr = context.obtainStyledAttributes(attrs, R.styleable.MyEditText, 0, 0); this.disableEmoticons=attr.getBoolean(R.styleable.MyEditText_disableEmoticons, disableEmoticons); this.fontType=attr.getInt(R.styleable.MyEditText_fontType, 0); // Set TypeFace Typeface typeface = Typeface.createFromAsset(getContext().getAssets(), fontNames[fontType]); setTypeface(typeface); if(disableEmoticons) { InputFilter curFilters[] = getFilters(); if (curFilters != null) { InputFilter newFilters[] = new InputFilter[curFilters.length + 1]; System.arraycopy(curFilters, 0, newFilters, 0, curFilters.length); newFilters[curFilters.length] = new EmojiExcludeFilter(context); setFilters(newFilters); } } } /** Default it is enabled * @param disableEmoticons true: Disable emoticons, false: enable emoticons * */ public void setDisableEmoticons(boolean disableEmoticons) { this.disableEmoticons=disableEmoticons; invalidate(); } }11)MyTextView.java========================package com.eppico.widgets; import android.content.Context;import android.content.res.TypedArray;import android.graphics.Typeface;import android.text.InputFilter;import android.util.AttributeSet;import android.widget.EditText;import android.widget.TextView; import com.eppico.R; public class MyTextView extends TextView { Context context; int fontType; String fontNames[]; public MyTextView(Context context) { this(context,null); } public MyTextView(Context context, AttributeSet attrs) { this(context,attrs,android.R.attr.textViewStyle); } public MyTextView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); this.context = context; fontNames=context.getResources().getStringArray(R.array.fontNames); init(context,attrs); } private void init(Context context,AttributeSet attrs) { TypedArray attr = context.obtainStyledAttributes(attrs, R.styleable.MyEditText, 0, 0); this.fontType=attr.getInt(R.styleable.MyTextView_fontType, 0); // Set TypeFace Typeface typeface = Typeface.createFromAsset(getContext().getAssets(), fontNames[fontType]); setTypeface(typeface); } }12)ShapedImageView.java========================package com.eppico.widgets; import android.content.Context;import android.content.res.TypedArray;import android.graphics.Bitmap;import android.graphics.Canvas;import android.graphics.Color;import android.graphics.Paint;import android.graphics.Path;import android.graphics.PorterDuff;import android.graphics.PorterDuffXfermode;import android.graphics.RectF;import android.graphics.drawable.shapes.RoundRectShape;import android.graphics.drawable.shapes.Shape;import android.os.Build;import android.util.AttributeSet;import android.widget.ImageView; import com.eppico.R; import java.util.Arrays; public class ShapedImageView extends ImageView { public static final int SHAPE_MODE_ROUND_RECT = 1; public static final int SHAPE_MODE_CIRCLE = 2; private static final int LAYER_FLAGS = Canvas.MATRIX_SAVE_FLAG | Canvas.CLIP_SAVE_FLAG | Canvas.HAS_ALPHA_LAYER_SAVE_FLAG | Canvas.FULL_COLOR_LAYER_SAVE_FLAG | Canvas.CLIP_TO_LAYER_SAVE_FLAG; private int mShapeMode = 0; private float mRadius = 0; private int mStrokeColor = 0x26000000; private float mStrokeWidth = 0; private Path mPath; private Shape mShape, mStrokeShape; private Paint mPaint, mStrokePaint, mPathPaint; private Bitmap mStrokeBitmap; private PathExtension mExtension; public ShapedImageView(Context context) { super(context); init(null); } public ShapedImageView(Context context, AttributeSet attrs) { super(context, attrs); init(attrs); } public ShapedImageView(Context context, AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); init(attrs); } private void init(AttributeSet attrs) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) { setLayerType(LAYER_TYPE_HARDWARE, null); } if (attrs != null) { TypedArray a = getContext().obtainStyledAttributes(attrs, R.styleable.ShapedImageView); mShapeMode = a.getInt(R.styleable.ShapedImageView_shape_mode, 2); mRadius = a.getDimension(R.styleable.ShapedImageView_round_radius, 0); mStrokeWidth = a.getDimension(R.styleable.ShapedImageView_stroke_width, 0); mStrokeColor = a.getColor(R.styleable.ShapedImageView_stroke_color, mStrokeColor); a.recycle(); } mPaint = new Paint(Paint.ANTI_ALIAS_FLAG); mPaint.setFilterBitmap(true); mPaint.setColor(Color.BLACK); mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN)); mStrokePaint = new Paint(Paint.ANTI_ALIAS_FLAG); mStrokePaint.setFilterBitmap(true); mStrokePaint.setColor(mStrokeColor); mPathPaint = new Paint(Paint.ANTI_ALIAS_FLAG); mPathPaint.setFilterBitmap(true); mPathPaint.setColor(Color.BLACK); mPathPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.XOR)); mPath = new Path(); } @Override protected void onLayout(boolean changed, int left, int top, int right, int bottom) { super.onLayout(changed, left, top, right, bottom); if (changed) { switch (mShapeMode) { case SHAPE_MODE_ROUND_RECT: break; case SHAPE_MODE_CIRCLE: int min = Math.min(getWidth(), getHeight()); mRadius = (float) min / 2; break; } if (mShape == null) { float[] radius = new float[8]; Arrays.fill(radius, mRadius); mShape = new RoundRectShape(radius, null, null); mStrokeShape = new RoundRectShape(radius, null, null); } mShape.resize(getWidth(), getHeight()); mStrokeShape.resize(getWidth() - mStrokeWidth * 2, getHeight() - mStrokeWidth * 2); if (mStrokeWidth > 0 && mStrokeBitmap == null) { mStrokeBitmap = makeStrokeBitmap(getWidth(), getHeight()); } if (mExtension != null) { mExtension.onLayout(mPath, getWidth(), getHeight()); } } } @Override protected void onDraw(Canvas canvas) { super.onDraw(canvas); if (mStrokeWidth > 0 && mStrokeShape != null && mStrokeBitmap != null) { int i = canvas.saveLayer(0, 0, getWidth(), getHeight(), null, LAYER_FLAGS); mStrokePaint.setXfermode(null); canvas.drawBitmap(mStrokeBitmap, 0, 0, mStrokePaint); canvas.translate(mStrokeWidth, mStrokeWidth); mStrokePaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_OUT)); mStrokeShape.draw(canvas, mStrokePaint); canvas.restoreToCount(i); } if (mExtension != null) { canvas.drawPath(mPath, mPathPaint); } switch (mShapeMode) { case SHAPE_MODE_ROUND_RECT: case SHAPE_MODE_CIRCLE: if (mShape != null) { mShape.draw(canvas, mPaint); } break; } } @Override protected void onAttachedToWindow() { super.onAttachedToWindow(); if (mStrokeWidth > 0 && mStrokeBitmap == null && mStrokeShape != null) { mStrokeBitmap = makeStrokeBitmap(getWidth(), getHeight()); } } @Override protected void onDetachedFromWindow() { super.onDetachedFromWindow(); if (mStrokeBitmap != null) { mStrokeBitmap.recycle(); mStrokeBitmap = null; } } private Bitmap makeStrokeBitmap(int w, int h) { Bitmap bm = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888); Canvas c = new Canvas(bm); Paint p = new Paint(Paint.ANTI_ALIAS_FLAG); p.setColor(mStrokeColor); c.drawRect(new RectF(0, 0, w, h), p); return bm; } public void setExtension(PathExtension extension) { mExtension = extension; requestLayout(); } public interface PathExtension { void onLayout(Path path, int width, int height); } public void setShapeMode(int shapeMode) { this.mShapeMode=shapeMode; invalidate(); } }13)TextViewRobotoBold.java==========================package com.eppico.widgets; import android.content.Context;import android.graphics.Typeface;import android.util.AttributeSet;import android.widget.TextView; public class TextViewRobotoBold extends TextView { Context context; public TextViewRobotoBold(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); this.context = context; init(context); } public TextViewRobotoBold(Context context, AttributeSet attrs) { super(context, attrs); this.context = context; init(context); } public TextViewRobotoBold(Context context) { super(context); this.context = context; init(context); } private void init(Context context) {// if (!isInEditMode()) { Typeface tf = Typeface.createFromAsset(getContext().getAssets(), "Roboto-Bold_3.ttf"); setTypeface(tf);// } }}14)TouchImageView.java==============================package com.eppico.widgets; import android.annotation.TargetApi;import android.content.Context;import android.graphics.Bitmap;import android.graphics.Matrix;import android.graphics.PointF;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.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; public 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; // // 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; // // After setting image, a value of true means the new image should maintain // the zoom of the previous image. False means it should be resized within // the view. // private boolean maintainZoomAfterSetImage; // // True when maintainZoomAfterSetImage has been set to true and setImage has // been called. // private boolean setImageCalledRecenterImage; private ScaleGestureDetector mScaleDetector; private GestureDetector mGestureDetector; public TouchImageView(Context context) { super(context); sharedConstructing(context); } public TouchImageView(Context context, AttributeSet attrs) { super(context, attrs); sharedConstructing(context); } public TouchImageView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); sharedConstructing(context); } 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; minScale = 1; maxScale = 3; superMinScale = SUPER_MIN_MULTIPLIER * minScale; superMaxScale = SUPER_MAX_MULTIPLIER * maxScale; maintainZoomAfterSetImage = true; setImageMatrix(matrix); setScaleType(ScaleType.MATRIX); setState(State.NONE); setOnTouchListener(new TouchImageViewListener()); } public void enableZoom(boolean enable) { if(enable) setOnTouchListener(new TouchImageViewListener()); else setOnTouchListener(null); } @Override public void setImageResource(int resId) { super.setImageResource(resId); setImageCalled(); savePreviousImageValues(); fitImageToView(); } @Override public void setImageBitmap(Bitmap bm) { super.setImageBitmap(bm); setImageCalled(); savePreviousImageValues(); fitImageToView(); } @Override public void setImageDrawable(Drawable drawable) { super.setImageDrawable(drawable); setImageCalled(); savePreviousImageValues(); fitImageToView(); } @Override public void setImageURI(Uri uri) { super.setImageURI(uri); setImageCalled(); savePreviousImageValues(); fitImageToView(); } private void setImageCalled() { if (!maintainZoomAfterSetImage) { setImageCalledRecenterImage = true; } } /** * Save the current matrix and view dimensions in the prevMatrix and * prevView variables. */ private void savePreviousImageValues() { if (matrix != null) { matrix.getValues(m); prevMatrix.setValues(m); prevMatchViewHeight = matchViewHeight; prevMatchViewWidth = matchViewWidth; prevViewHeight = viewHeight; prevViewWidth = viewWidth; } } @Override public Parcelable onSaveInstanceState() { Bundle bundle = new Bundle(); bundle.putParcelable("instanceState", super.onSaveInstanceState()); bundle.putFloat("saveScale", normalizedScale); bundle.putFloat("matchViewHeight", matchViewHeight); bundle.putFloat("matchViewWidth", matchViewWidth); bundle.putInt("viewWidth", viewWidth); bundle.putInt("viewHeight", viewHeight); matrix.getValues(m); bundle.putFloatArray("matrix", m); return bundle; } @Override public void onRestoreInstanceState(Parcelable state) { if (state instanceof Bundle) { Bundle bundle = (Bundle) state; normalizedScale = bundle.getFloat("saveScale"); m = bundle.getFloatArray("matrix"); prevMatrix.setValues(m); prevMatchViewHeight = bundle.getFloat("matchViewHeight"); prevMatchViewWidth = bundle.getFloat("matchViewWidth"); prevViewHeight = bundle.getInt("viewHeight"); prevViewWidth = bundle.getInt("viewWidth"); super.onRestoreInstanceState(bundle.getParcelable("instanceState")); return; } super.onRestoreInstanceState(state); } /** * 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; } /** * After setting image, a value of true means the new image should maintain * the zoom of the previous image. False means the image should be resized * within the view. Defaults value is true. * * @param maintainZoom */ public void maintainZoomAfterSetImage(boolean maintainZoom) { maintainZoomAfterSetImage = maintainZoom; } /** * 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; } /** * For a given point on the view (ie, a touch event), returns the point * relative to the original drawable's coordinate system. * * @param x * @param y * @return PointF relative to original drawable's coordinate system. */ public PointF getDrawablePointFromTouchPoint(float x, float y) { return transformCoordTouchToBitmap(x, y, true); } /** * For a given point on the view (ie, a touch event), returns the point * relative to the original drawable's coordinate system. * * @param p * @return PointF relative to original drawable's coordinate system. */ public PointF getDrawablePointFromTouchPoint(PointF p) { return transformCoordTouchToBitmap(p.x, p.y, true); } /** * 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; float scale = Math.min(scaleX, scaleY); // // Center the image // float redundantYSpace = viewHeight - (scale * drawableHeight); float redundantXSpace = viewWidth - (scale * drawableWidth); matchViewWidth = viewWidth - redundantXSpace; matchViewHeight = viewHeight - redundantYSpace; if (normalizedScale == 1 || setImageCalledRecenterImage) { // // Stretch and center image to fit view // matrix.setScale(scale, scale); matrix.postTranslate(redundantXSpace / 2, redundantYSpace / 2); normalizedScale = 1; setImageCalledRecenterImage = false; } else { 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); } 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; } /** * 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) { 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 (state == State.NONE) { float targetZoom = (normalizedScale == minScale) ? maxScale : minScale; DoubleTapZoom doubleTap = new DoubleTapZoom(targetZoom, e.getX(), e.getY(), false); compatPostOnAnimation(doubleTap); consumed = true; } return consumed; } } /** * Responsible for all touch events. Handles the heavy lifting of drag and * also sends touch events to Scale Detector and Gesture Detector. * * @author Ortiz * */ private class TouchImageViewListener implements OnTouchListener { // // Remember last point position for dragging // private PointF last = new PointF(); @Override public boolean onTouch(View v, MotionEvent event) { mScaleDetector.onTouchEvent(event); mGestureDetector.onTouchEvent(event); PointF curr = new PointF(event.getX(), event.getY()); if (state == State.NONE || state == State.DRAG || state == State.FLING) { switch (event.getAction()) { case MotionEvent.ACTION_DOWN: last.set(curr); if (fling != null) fling.cancelFling(); setState(State.DRAG); break; case MotionEvent.ACTION_MOVE: if (state == State.DRAG) { float deltaX = curr.x - last.x; float deltaY = curr.y - last.y; float fixTransX = getFixDragTrans(deltaX, viewWidth, getImageWidth()); float fixTransY = getFixDragTrans(deltaY, viewHeight, getImageHeight()); matrix.postTranslate(fixTransX, fixTransY); fixTrans(); last.set(curr.x, curr.y); } break; case MotionEvent.ACTION_UP: case MotionEvent.ACTION_POINTER_UP: setState(State.NONE); break; } } setImageMatrix(matrix); // // indicate event was handled // return true; } } /** * ScaleListener detects user two finger scaling and scales image. * * @author Ortiz * */ private class ScaleListener extends ScaleGestureDetector.SimpleOnScaleGestureListener { @Override public boolean onScaleBegin(ScaleGestureDetector detector) { setState(State.ZOOM); return true; } @Override public boolean onScale(ScaleGestureDetector detector) { scaleImage(detector.getScaleFactor(), detector.getFocusX(), detector.getFocusY(), true); return true; } @Override public void onScaleEnd(ScaleGestureDetector detector) { super.onScaleEnd(detector); setState(State.NONE); boolean animateToZoomBoundary = false; float targetZoom = normalizedScale; if (normalizedScale > maxScale) { targetZoom = maxScale; animateToZoomBoundary = true; } else if (normalizedScale < minScale) { targetZoom = minScale; animateToZoomBoundary = true; } if (animateToZoomBoundary) { DoubleTapZoom doubleTap = new DoubleTapZoom(targetZoom, viewWidth / 2, viewHeight / 2, true); compatPostOnAnimation(doubleTap); } } } private void scaleImage(float deltaScale, float focusX, float focusY, boolean stretchImageToSuper) { float lowerScale, upperScale; if (stretchImageToSuper) { lowerScale = superMinScale; upperScale = superMaxScale; } else { lowerScale = minScale; upperScale = maxScale; } float origScale = normalizedScale; normalizedScale *= deltaScale; if (normalizedScale > upperScale) { normalizedScale = upperScale; deltaScale = upperScale / origScale; } else if (normalizedScale < lowerScale) { normalizedScale = lowerScale; deltaScale = lowerScale / origScale; } matrix.postScale(deltaScale, deltaScale, focusX, focusY); fixScaleTrans(); } /** * 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(); float deltaScale = calculateDeltaScale(t); scaleImage(deltaScale, bitmapX, bitmapY, stretchImageToSuper); translateImageToCenterTouchPosition(t); fixScaleTrans(); setImageMatrix(matrix); 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 float calculateDeltaScale(float t) { float 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(x, 0), origW); finalY = Math.min(Math.max(y, 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 { Scroller scroller; int currX, currY; Fling(int velocityX, int velocityY) { setState(State.FLING); scroller = new Scroller(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() { 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(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 void printMatrixInfo() { matrix.getValues(m); Log.d(DEBUG, "Scale: " + m[Matrix.MSCALE_X] + " TransX: " + m[Matrix.MTRANS_X] + " TransY: " + m[Matrix.MTRANS_Y]); } }
No comments:
Post a Comment