mirror of https://codeberg.org/tom79/Fedilab
Thomas
2 years ago
commit
089d6b9ba8
File diff suppressed because it is too large
Load Diff
|
|
|
|
|
|
|
|
|
|
|
|
@ -1,47 +0,0 @@
|
||||
[
|
||||
{
|
||||
"theme_name": "Dark",
|
||||
"base_theme": "DARK",
|
||||
"primary": "#FF272727",
|
||||
"primary_dark": "#FF272727",
|
||||
"primary_light": "#FFd9e1e8",
|
||||
"accent": "#FF2b90d9",
|
||||
"accent_dark": "#FF1b80c9",
|
||||
"accent_light": "#FF772b90d9",
|
||||
"background": "#FF272727",
|
||||
"background_dark": "#FF282c37",
|
||||
"background_light": "#FF282c37",
|
||||
"should_tint_statusbar": true,
|
||||
"should_tint_navbar": true
|
||||
},
|
||||
{
|
||||
"theme_name": "Light",
|
||||
"base_theme": "LIGHT",
|
||||
"primary": "#FFFFFF",
|
||||
"primary_dark": "#FFFFFFFF",
|
||||
"primary_light": "#FFd9e1e8",
|
||||
"accent": "#FF2b90d9",
|
||||
"accent_dark": "#FF1b80c9",
|
||||
"accent_light": "#FF772b90d9",
|
||||
"background": "#FFFFFFFF",
|
||||
"background_dark": "#FFFFFFFF",
|
||||
"background_light": "#FFFFFFFF",
|
||||
"should_tint_statusbar": true,
|
||||
"should_tint_navbar": true
|
||||
},
|
||||
{
|
||||
"theme_name": "Black",
|
||||
"base_theme": "DARK",
|
||||
"primary": "#FF000000",
|
||||
"primary_dark": "#FF000000",
|
||||
"primary_light": "#FF000000",
|
||||
"accent": "#FF606984",
|
||||
"accent_dark": "#FF606984",
|
||||
"accent_light": "#FF606984",
|
||||
"background": "#FF000000",
|
||||
"background_dark": "#FF000000",
|
||||
"background_light": "#FF000000",
|
||||
"should_tint_statusbar": true,
|
||||
"should_tint_navbar": true
|
||||
}
|
||||
]
|
||||
@ -0,0 +1,34 @@
|
||||
package app.fedilab.android.client.entities.app;
|
||||
/* Copyright 2022 Thomas Schneider
|
||||
*
|
||||
* This file is a part of Fedilab
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it under the terms of the
|
||||
* GNU General Public License as published by the Free Software Foundation; either version 3 of the
|
||||
* License, or (at your option) any later version.
|
||||
*
|
||||
* Fedilab is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
|
||||
* the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
|
||||
* Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along with Fedilab; if not,
|
||||
* see <http://www.gnu.org/licenses>. */
|
||||
|
||||
import com.google.gson.annotations.SerializedName;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.List;
|
||||
|
||||
|
||||
public class Quotes implements Serializable {
|
||||
|
||||
@SerializedName("quotes")
|
||||
public List<Quote> quotes;
|
||||
|
||||
public static class Quote implements Serializable {
|
||||
@SerializedName("author")
|
||||
public String author;
|
||||
@SerializedName("content")
|
||||
public String content;
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,5 @@
|
||||
package app.fedilab.android.interfaces;
|
||||
|
||||
public interface ProgressListener {
|
||||
void onProgress(long transferred, long total);
|
||||
}
|
||||
@ -0,0 +1,5 @@
|
||||
<shape xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:shape="rectangle">
|
||||
<solid android:color="?colorSurfaceVariant" />
|
||||
<corners android:radius="12dp" />
|
||||
</shape>
|
||||
@ -0,0 +1,12 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<menu xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
xmlns:app="http://schemas.android.com/apk/res-auto">
|
||||
<item
|
||||
android:id="@+id/action_displayname"
|
||||
android:title="@string/change_tag_column"
|
||||
app:showAsAction="always" />
|
||||
<item
|
||||
android:id="@+id/action_nitter_manage_accounts"
|
||||
android:title="@string/manage_accounts"
|
||||
app:showAsAction="always" />
|
||||
</menu>
|
||||
@ -1,22 +0,0 @@
|
||||
apply plugin: 'com.android.library'
|
||||
|
||||
android {
|
||||
|
||||
compileSdk 31
|
||||
defaultConfig {
|
||||
minSdkVersion 14
|
||||
}
|
||||
compileOptions {
|
||||
sourceCompatibility JavaVersion.VERSION_1_8
|
||||
targetCompatibility JavaVersion.VERSION_1_8
|
||||
}
|
||||
lintOptions {
|
||||
abortOnError false
|
||||
}
|
||||
}
|
||||
|
||||
dependencies {
|
||||
api 'androidx.appcompat:appcompat:1.4.2'
|
||||
implementation "androidx.exifinterface:exifinterface:1.3.3"
|
||||
}
|
||||
|
||||
@ -1,3 +0,0 @@
|
||||
<manifest package="com.theartofdev.edmodo.cropper">
|
||||
|
||||
</manifest>
|
||||
@ -1,354 +0,0 @@
|
||||
// "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.theartofdev.edmodo.cropper;
|
||||
|
||||
import android.content.Context;
|
||||
import android.graphics.Bitmap;
|
||||
import android.net.Uri;
|
||||
import android.os.AsyncTask;
|
||||
|
||||
import java.lang.ref.WeakReference;
|
||||
|
||||
/**
|
||||
* Task to crop bitmap asynchronously from the UI thread.
|
||||
*/
|
||||
final 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 4 points (x0,y0,x1,y1,x2,y2,x3,y3)
|
||||
*/
|
||||
private final float[] mCropPoints;
|
||||
|
||||
/**
|
||||
* Degrees the image was rotated after loading
|
||||
*/
|
||||
private final int mDegreesRotated;
|
||||
|
||||
/**
|
||||
* the original width of the image to be cropped (for image loaded from URI)
|
||||
*/
|
||||
private final int mOrgWidth;
|
||||
|
||||
/**
|
||||
* the original height of the image to be cropped (for image loaded from URI)
|
||||
*/
|
||||
private final int mOrgHeight;
|
||||
|
||||
/**
|
||||
* is there is fixed aspect ratio for the crop rectangle
|
||||
*/
|
||||
private final boolean mFixAspectRatio;
|
||||
|
||||
/**
|
||||
* the X aspect ration of the crop rectangle
|
||||
*/
|
||||
private final int mAspectRatioX;
|
||||
|
||||
/**
|
||||
* the Y aspect ration of the crop rectangle
|
||||
*/
|
||||
private final int mAspectRatioY;
|
||||
|
||||
/**
|
||||
* required width of the cropping image
|
||||
*/
|
||||
private final int mReqWidth;
|
||||
|
||||
/**
|
||||
* required height of the cropping image
|
||||
*/
|
||||
private final int mReqHeight;
|
||||
|
||||
/**
|
||||
* is the image flipped horizontally
|
||||
*/
|
||||
private final boolean mFlipHorizontally;
|
||||
|
||||
/**
|
||||
* is the image flipped vertically
|
||||
*/
|
||||
private final boolean mFlipVertically;
|
||||
|
||||
/**
|
||||
* The option to handle requested width/height
|
||||
*/
|
||||
private final CropImageView.RequestSizeOptions mReqSizeOptions;
|
||||
|
||||
/**
|
||||
* the Android Uri to save the cropped image to
|
||||
*/
|
||||
private final Uri mSaveUri;
|
||||
|
||||
/**
|
||||
* the compression format to use when writing the image
|
||||
*/
|
||||
private final Bitmap.CompressFormat mSaveCompressFormat;
|
||||
|
||||
/**
|
||||
* the quality (if applicable) to use when writing the image (0 - 100)
|
||||
*/
|
||||
private final int mSaveCompressQuality;
|
||||
// endregion
|
||||
|
||||
BitmapCroppingWorkerTask(
|
||||
CropImageView cropImageView,
|
||||
Bitmap bitmap,
|
||||
float[] cropPoints,
|
||||
int degreesRotated,
|
||||
boolean fixAspectRatio,
|
||||
int aspectRatioX,
|
||||
int aspectRatioY,
|
||||
int reqWidth,
|
||||
int reqHeight,
|
||||
boolean flipHorizontally,
|
||||
boolean flipVertically,
|
||||
CropImageView.RequestSizeOptions options,
|
||||
Uri saveUri,
|
||||
Bitmap.CompressFormat saveCompressFormat,
|
||||
int saveCompressQuality) {
|
||||
|
||||
mCropImageViewReference = new WeakReference<>(cropImageView);
|
||||
mContext = cropImageView.getContext();
|
||||
mBitmap = bitmap;
|
||||
mCropPoints = cropPoints;
|
||||
mUri = null;
|
||||
mDegreesRotated = degreesRotated;
|
||||
mFixAspectRatio = fixAspectRatio;
|
||||
mAspectRatioX = aspectRatioX;
|
||||
mAspectRatioY = aspectRatioY;
|
||||
mReqWidth = reqWidth;
|
||||
mReqHeight = reqHeight;
|
||||
mFlipHorizontally = flipHorizontally;
|
||||
mFlipVertically = flipVertically;
|
||||
mReqSizeOptions = options;
|
||||
mSaveUri = saveUri;
|
||||
mSaveCompressFormat = saveCompressFormat;
|
||||
mSaveCompressQuality = saveCompressQuality;
|
||||
mOrgWidth = 0;
|
||||
mOrgHeight = 0;
|
||||
}
|
||||
|
||||
BitmapCroppingWorkerTask(
|
||||
CropImageView cropImageView,
|
||||
Uri uri,
|
||||
float[] cropPoints,
|
||||
int degreesRotated,
|
||||
int orgWidth,
|
||||
int orgHeight,
|
||||
boolean fixAspectRatio,
|
||||
int aspectRatioX,
|
||||
int aspectRatioY,
|
||||
int reqWidth,
|
||||
int reqHeight,
|
||||
boolean flipHorizontally,
|
||||
boolean flipVertically,
|
||||
CropImageView.RequestSizeOptions options,
|
||||
Uri saveUri,
|
||||
Bitmap.CompressFormat saveCompressFormat,
|
||||
int saveCompressQuality) {
|
||||
|
||||
mCropImageViewReference = new WeakReference<>(cropImageView);
|
||||
mContext = cropImageView.getContext();
|
||||
mUri = uri;
|
||||
mCropPoints = cropPoints;
|
||||
mDegreesRotated = degreesRotated;
|
||||
mFixAspectRatio = fixAspectRatio;
|
||||
mAspectRatioX = aspectRatioX;
|
||||
mAspectRatioY = aspectRatioY;
|
||||
mOrgWidth = orgWidth;
|
||||
mOrgHeight = orgHeight;
|
||||
mReqWidth = reqWidth;
|
||||
mReqHeight = reqHeight;
|
||||
mFlipHorizontally = flipHorizontally;
|
||||
mFlipVertically = flipVertically;
|
||||
mReqSizeOptions = options;
|
||||
mSaveUri = saveUri;
|
||||
mSaveCompressFormat = saveCompressFormat;
|
||||
mSaveCompressQuality = saveCompressQuality;
|
||||
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 BitmapCroppingWorkerTask.Result doInBackground(Void... params) {
|
||||
try {
|
||||
if (!isCancelled()) {
|
||||
|
||||
BitmapUtils.BitmapSampled bitmapSampled;
|
||||
if (mUri != null) {
|
||||
bitmapSampled =
|
||||
BitmapUtils.cropBitmap(
|
||||
mContext,
|
||||
mUri,
|
||||
mCropPoints,
|
||||
mDegreesRotated,
|
||||
mOrgWidth,
|
||||
mOrgHeight,
|
||||
mFixAspectRatio,
|
||||
mAspectRatioX,
|
||||
mAspectRatioY,
|
||||
mReqWidth,
|
||||
mReqHeight,
|
||||
mFlipHorizontally,
|
||||
mFlipVertically);
|
||||
} else if (mBitmap != null) {
|
||||
bitmapSampled =
|
||||
BitmapUtils.cropBitmapObjectHandleOOM(
|
||||
mBitmap,
|
||||
mCropPoints,
|
||||
mDegreesRotated,
|
||||
mFixAspectRatio,
|
||||
mAspectRatioX,
|
||||
mAspectRatioY,
|
||||
mFlipHorizontally,
|
||||
mFlipVertically);
|
||||
} else {
|
||||
return new Result((Bitmap) null, 1);
|
||||
}
|
||||
|
||||
Bitmap bitmap =
|
||||
BitmapUtils.resizeBitmap(bitmapSampled.bitmap, mReqWidth, mReqHeight, mReqSizeOptions);
|
||||
|
||||
if (mSaveUri == null) {
|
||||
return new Result(bitmap, bitmapSampled.sampleSize);
|
||||
} else {
|
||||
BitmapUtils.writeBitmapToUri(
|
||||
mContext, bitmap, mSaveUri, mSaveCompressFormat, mSaveCompressQuality);
|
||||
if (bitmap != null) {
|
||||
bitmap.recycle();
|
||||
}
|
||||
return new Result(mSaveUri, bitmapSampled.sampleSize);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
} catch (Exception e) {
|
||||
return new Result(e, mSaveUri != null);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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.onImageCroppingAsyncComplete(result);
|
||||
}
|
||||
}
|
||||
if (!completeCalled && result.bitmap != null) {
|
||||
// fast release of unused bitmap
|
||||
result.bitmap.recycle();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// region: Inner class: Result
|
||||
|
||||
/**
|
||||
* The result of BitmapCroppingWorkerTask async loading.
|
||||
*/
|
||||
static final class Result {
|
||||
|
||||
/**
|
||||
* The cropped bitmap
|
||||
*/
|
||||
public final Bitmap bitmap;
|
||||
|
||||
/**
|
||||
* The saved cropped bitmap uri
|
||||
*/
|
||||
public final Uri uri;
|
||||
|
||||
/**
|
||||
* The error that occurred during async bitmap cropping.
|
||||
*/
|
||||
final Exception error;
|
||||
|
||||
/**
|
||||
* is the cropping request was to get a bitmap or to save it to uri
|
||||
*/
|
||||
final boolean isSave;
|
||||
|
||||
/**
|
||||
* sample size used creating the crop bitmap to lower its size
|
||||
*/
|
||||
final int sampleSize;
|
||||
|
||||
Result(Bitmap bitmap, int sampleSize) {
|
||||
this.bitmap = bitmap;
|
||||
this.uri = null;
|
||||
this.error = null;
|
||||
this.isSave = false;
|
||||
this.sampleSize = sampleSize;
|
||||
}
|
||||
|
||||
Result(Uri uri, int sampleSize) {
|
||||
this.bitmap = null;
|
||||
this.uri = uri;
|
||||
this.error = null;
|
||||
this.isSave = true;
|
||||
this.sampleSize = sampleSize;
|
||||
}
|
||||
|
||||
Result(Exception error, boolean isSave) {
|
||||
this.bitmap = null;
|
||||
this.uri = null;
|
||||
this.error = error;
|
||||
this.isSave = isSave;
|
||||
this.sampleSize = 1;
|
||||
}
|
||||
}
|
||||
// endregion
|
||||
}
|
||||
@ -1,176 +0,0 @@
|
||||
// "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.theartofdev.edmodo.cropper;
|
||||
|
||||
import android.content.Context;
|
||||
import android.graphics.Bitmap;
|
||||
import android.net.Uri;
|
||||
import android.os.AsyncTask;
|
||||
import android.util.DisplayMetrics;
|
||||
|
||||
import java.lang.ref.WeakReference;
|
||||
|
||||
/**
|
||||
* Task to load bitmap asynchronously from the UI thread.
|
||||
*/
|
||||
final 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;
|
||||
|
||||
/**
|
||||
* 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) {
|
||||
mUri = uri;
|
||||
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()) {
|
||||
|
||||
BitmapUtils.BitmapSampled decodeResult =
|
||||
BitmapUtils.decodeSampledBitmap(mContext, mUri, mWidth, mHeight);
|
||||
|
||||
if (!isCancelled()) {
|
||||
|
||||
BitmapUtils.RotateBitmapResult rotateResult =
|
||||
BitmapUtils.rotateBitmapByExif(decodeResult.bitmap, mContext, 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
|
||||
}
|
||||
@ -1,923 +0,0 @@
|
||||
// "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.theartofdev.edmodo.cropper;
|
||||
|
||||
import android.content.ContentResolver;
|
||||
import android.content.Context;
|
||||
import android.graphics.Bitmap;
|
||||
import android.graphics.BitmapFactory;
|
||||
import android.graphics.BitmapRegionDecoder;
|
||||
import android.graphics.Matrix;
|
||||
import android.graphics.Rect;
|
||||
import android.graphics.RectF;
|
||||
import android.net.Uri;
|
||||
import android.util.Log;
|
||||
import android.util.Pair;
|
||||
|
||||
import androidx.exifinterface.media.ExifInterface;
|
||||
|
||||
import java.io.Closeable;
|
||||
import java.io.File;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
import java.lang.ref.WeakReference;
|
||||
|
||||
import javax.microedition.khronos.egl.EGL10;
|
||||
import javax.microedition.khronos.egl.EGLConfig;
|
||||
import javax.microedition.khronos.egl.EGLContext;
|
||||
import javax.microedition.khronos.egl.EGLDisplay;
|
||||
|
||||
/**
|
||||
* Utility class that deals with operations with an ImageView.
|
||||
*/
|
||||
final class BitmapUtils {
|
||||
|
||||
static final Rect EMPTY_RECT = new Rect();
|
||||
|
||||
static final RectF EMPTY_RECT_F = new RectF();
|
||||
|
||||
/**
|
||||
* Reusable rectangle for general internal usage
|
||||
*/
|
||||
static final RectF RECT = new RectF();
|
||||
|
||||
/**
|
||||
* Reusable point for general internal usage
|
||||
*/
|
||||
static final float[] POINTS = new float[6];
|
||||
|
||||
/**
|
||||
* Reusable point for general internal usage
|
||||
*/
|
||||
static final float[] POINTS2 = new float[6];
|
||||
/**
|
||||
* used to save bitmaps during state save and restore so not to reload them.
|
||||
*/
|
||||
static Pair<String, WeakReference<Bitmap>> mStateBitmap;
|
||||
/**
|
||||
* Used to know the max texture size allowed to be rendered
|
||||
*/
|
||||
private static int mMaxTextureSize;
|
||||
|
||||
/**
|
||||
* Rotate the given image by reading the Exif value of the image (uri).<br>
|
||||
* If no rotation is required the image will not be rotated.<br>
|
||||
* New bitmap is created and the old one is recycled.
|
||||
*/
|
||||
static RotateBitmapResult rotateBitmapByExif(Bitmap bitmap, Context context, Uri uri) {
|
||||
ExifInterface ei = null;
|
||||
try {
|
||||
InputStream is = context.getContentResolver().openInputStream(uri);
|
||||
if (is != null) {
|
||||
ei = new ExifInterface(is);
|
||||
is.close();
|
||||
}
|
||||
} catch (Exception ignored) {
|
||||
}
|
||||
return ei != null ? rotateBitmapByExif(bitmap, ei) : new RotateBitmapResult(bitmap, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Rotate the given image by given Exif value.<br>
|
||||
* If no rotation is required the image will not be rotated.<br>
|
||||
* New bitmap is created and the old one is recycled.
|
||||
*/
|
||||
static RotateBitmapResult rotateBitmapByExif(Bitmap bitmap, ExifInterface exif) {
|
||||
int degrees;
|
||||
int orientation =
|
||||
exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
|
||||
switch (orientation) {
|
||||
case ExifInterface.ORIENTATION_ROTATE_90:
|
||||
degrees = 90;
|
||||
break;
|
||||
case ExifInterface.ORIENTATION_ROTATE_180:
|
||||
degrees = 180;
|
||||
break;
|
||||
case ExifInterface.ORIENTATION_ROTATE_270:
|
||||
degrees = 270;
|
||||
break;
|
||||
default:
|
||||
degrees = 0;
|
||||
break;
|
||||
}
|
||||
return new RotateBitmapResult(bitmap, degrees);
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode bitmap from stream using sampling to get bitmap with the requested limit.
|
||||
*/
|
||||
static BitmapSampled decodeSampledBitmap(Context context, Uri uri, int reqWidth, int reqHeight) {
|
||||
|
||||
try {
|
||||
ContentResolver resolver = context.getContentResolver();
|
||||
|
||||
// First decode with inJustDecodeBounds=true to check dimensions
|
||||
BitmapFactory.Options options = decodeImageForOption(resolver, uri);
|
||||
|
||||
if (options.outWidth == -1 && options.outHeight == -1)
|
||||
throw new RuntimeException("File is not a picture");
|
||||
|
||||
// Calculate inSampleSize
|
||||
options.inSampleSize =
|
||||
Math.max(
|
||||
calculateInSampleSizeByReqestedSize(
|
||||
options.outWidth, options.outHeight, reqWidth, reqHeight),
|
||||
calculateInSampleSizeByMaxTextureSize(options.outWidth, options.outHeight));
|
||||
|
||||
// Decode bitmap with inSampleSize set
|
||||
Bitmap bitmap = decodeImage(resolver, uri, options);
|
||||
|
||||
return new BitmapSampled(bitmap, options.inSampleSize);
|
||||
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(
|
||||
"Failed to load sampled bitmap: " + uri + "\r\n" + e.getMessage(), e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Crop image bitmap from given bitmap using the given points in the original bitmap and the given
|
||||
* rotation.<br>
|
||||
* if the rotation is not 0,90,180 or 270 degrees then we must first crop a larger area of the
|
||||
* image that contains the requires rectangle, rotate and then crop again a sub rectangle.<br>
|
||||
* If crop fails due to OOM we scale the cropping image by 0.5 every time it fails until it is
|
||||
* small enough.
|
||||
*/
|
||||
static BitmapSampled cropBitmapObjectHandleOOM(
|
||||
Bitmap bitmap,
|
||||
float[] points,
|
||||
int degreesRotated,
|
||||
boolean fixAspectRatio,
|
||||
int aspectRatioX,
|
||||
int aspectRatioY,
|
||||
boolean flipHorizontally,
|
||||
boolean flipVertically) {
|
||||
int scale = 1;
|
||||
while (true) {
|
||||
try {
|
||||
Bitmap cropBitmap =
|
||||
cropBitmapObjectWithScale(
|
||||
bitmap,
|
||||
points,
|
||||
degreesRotated,
|
||||
fixAspectRatio,
|
||||
aspectRatioX,
|
||||
aspectRatioY,
|
||||
1 / (float) scale,
|
||||
flipHorizontally,
|
||||
flipVertically);
|
||||
return new BitmapSampled(cropBitmap, scale);
|
||||
} catch (OutOfMemoryError e) {
|
||||
scale *= 2;
|
||||
if (scale > 8) {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Crop image bitmap from given bitmap using the given points in the original bitmap and the given
|
||||
* rotation.<br>
|
||||
* if the rotation is not 0,90,180 or 270 degrees then we must first crop a larger area of the
|
||||
* image that contains the requires rectangle, rotate and then crop again a sub rectangle.
|
||||
*
|
||||
* @param scale how much to scale the cropped image part, use 0.5 to lower the image by half (OOM
|
||||
* handling)
|
||||
*/
|
||||
private static Bitmap cropBitmapObjectWithScale(
|
||||
Bitmap bitmap,
|
||||
float[] points,
|
||||
int degreesRotated,
|
||||
boolean fixAspectRatio,
|
||||
int aspectRatioX,
|
||||
int aspectRatioY,
|
||||
float scale,
|
||||
boolean flipHorizontally,
|
||||
boolean flipVertically) {
|
||||
|
||||
// get the rectangle in original image that contains the required cropped area (larger for non
|
||||
// rectangular crop)
|
||||
Rect rect =
|
||||
getRectFromPoints(
|
||||
points,
|
||||
bitmap.getWidth(),
|
||||
bitmap.getHeight(),
|
||||
fixAspectRatio,
|
||||
aspectRatioX,
|
||||
aspectRatioY);
|
||||
|
||||
// crop and rotate the cropped image in one operation
|
||||
Matrix matrix = new Matrix();
|
||||
matrix.setRotate(degreesRotated, bitmap.getWidth() / 2, bitmap.getHeight() / 2);
|
||||
matrix.postScale(flipHorizontally ? -scale : scale, flipVertically ? -scale : scale);
|
||||
Bitmap result =
|
||||
Bitmap.createBitmap(bitmap, rect.left, rect.top, rect.width(), rect.height(), matrix, true);
|
||||
|
||||
if (result == bitmap) {
|
||||
// corner case when all bitmap is selected, no worth optimizing for it
|
||||
result = bitmap.copy(bitmap.getConfig(), false);
|
||||
}
|
||||
|
||||
// rotating by 0, 90, 180 or 270 degrees doesn't require extra cropping
|
||||
if (degreesRotated % 90 != 0) {
|
||||
|
||||
// extra crop because non rectangular crop cannot be done directly on the image without
|
||||
// rotating first
|
||||
result =
|
||||
cropForRotatedImage(
|
||||
result, points, rect, degreesRotated, fixAspectRatio, aspectRatioX, aspectRatioY);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Crop image bitmap from URI by decoding it with specific width and height to down-sample if
|
||||
* required.<br>
|
||||
* Additionally if OOM is thrown try to increase the sampling (2,4,8).
|
||||
*/
|
||||
static BitmapSampled cropBitmap(
|
||||
Context context,
|
||||
Uri loadedImageUri,
|
||||
float[] points,
|
||||
int degreesRotated,
|
||||
int orgWidth,
|
||||
int orgHeight,
|
||||
boolean fixAspectRatio,
|
||||
int aspectRatioX,
|
||||
int aspectRatioY,
|
||||
int reqWidth,
|
||||
int reqHeight,
|
||||
boolean flipHorizontally,
|
||||
boolean flipVertically) {
|
||||
int sampleMulti = 1;
|
||||
while (true) {
|
||||
try {
|
||||
// if successful, just return the resulting bitmap
|
||||
return cropBitmap(
|
||||
context,
|
||||
loadedImageUri,
|
||||
points,
|
||||
degreesRotated,
|
||||
orgWidth,
|
||||
orgHeight,
|
||||
fixAspectRatio,
|
||||
aspectRatioX,
|
||||
aspectRatioY,
|
||||
reqWidth,
|
||||
reqHeight,
|
||||
flipHorizontally,
|
||||
flipVertically,
|
||||
sampleMulti);
|
||||
} catch (OutOfMemoryError e) {
|
||||
// if OOM try to increase the sampling to lower the memory usage
|
||||
sampleMulti *= 2;
|
||||
if (sampleMulti > 16) {
|
||||
throw new RuntimeException(
|
||||
"Failed to handle OOM by sampling ("
|
||||
+ sampleMulti
|
||||
+ "): "
|
||||
+ loadedImageUri
|
||||
+ "\r\n"
|
||||
+ e.getMessage(),
|
||||
e);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get left value of the bounding rectangle of the given points.
|
||||
*/
|
||||
static float getRectLeft(float[] points) {
|
||||
return Math.min(Math.min(Math.min(points[0], points[2]), points[4]), points[6]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get top value of the bounding rectangle of the given points.
|
||||
*/
|
||||
static float getRectTop(float[] points) {
|
||||
return Math.min(Math.min(Math.min(points[1], points[3]), points[5]), points[7]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get right value of the bounding rectangle of the given points.
|
||||
*/
|
||||
static float getRectRight(float[] points) {
|
||||
return Math.max(Math.max(Math.max(points[0], points[2]), points[4]), points[6]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get bottom value of the bounding rectangle of the given points.
|
||||
*/
|
||||
static float getRectBottom(float[] points) {
|
||||
return Math.max(Math.max(Math.max(points[1], points[3]), points[5]), points[7]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get width of the bounding rectangle of the given points.
|
||||
*/
|
||||
static float getRectWidth(float[] points) {
|
||||
return getRectRight(points) - getRectLeft(points);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get height of the bounding rectangle of the given points.
|
||||
*/
|
||||
static float getRectHeight(float[] points) {
|
||||
return getRectBottom(points) - getRectTop(points);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get horizontal center value of the bounding rectangle of the given points.
|
||||
*/
|
||||
static float getRectCenterX(float[] points) {
|
||||
return (getRectRight(points) + getRectLeft(points)) / 2f;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get vertical center value of the bounding rectangle of the given points.
|
||||
*/
|
||||
static float getRectCenterY(float[] points) {
|
||||
return (getRectBottom(points) + getRectTop(points)) / 2f;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a rectangle for the given 4 points (x0,y0,x1,y1,x2,y2,x3,y3) by finding the min/max 2
|
||||
* points that contains the given 4 points and is a straight rectangle.
|
||||
*/
|
||||
static Rect getRectFromPoints(
|
||||
float[] points,
|
||||
int imageWidth,
|
||||
int imageHeight,
|
||||
boolean fixAspectRatio,
|
||||
int aspectRatioX,
|
||||
int aspectRatioY) {
|
||||
int left = Math.round(Math.max(0, getRectLeft(points)));
|
||||
int top = Math.round(Math.max(0, getRectTop(points)));
|
||||
int right = Math.round(Math.min(imageWidth, getRectRight(points)));
|
||||
int bottom = Math.round(Math.min(imageHeight, getRectBottom(points)));
|
||||
|
||||
Rect rect = new Rect(left, top, right, bottom);
|
||||
if (fixAspectRatio) {
|
||||
fixRectForAspectRatio(rect, aspectRatioX, aspectRatioY);
|
||||
}
|
||||
|
||||
return rect;
|
||||
}
|
||||
|
||||
/**
|
||||
* Fix the given rectangle if it doesn't confirm to aspect ration rule.<br>
|
||||
* Make sure that width and height are equal if 1:1 fixed aspect ratio is requested.
|
||||
*/
|
||||
private static void fixRectForAspectRatio(Rect rect, int aspectRatioX, int aspectRatioY) {
|
||||
if (aspectRatioX == aspectRatioY && rect.width() != rect.height()) {
|
||||
if (rect.height() > rect.width()) {
|
||||
rect.bottom -= rect.height() - rect.width();
|
||||
} else {
|
||||
rect.right -= rect.width() - rect.height();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Write given bitmap to a temp file. If file already exists no-op as we already saved the file in
|
||||
* this session. Uses JPEG 95% compression.
|
||||
*
|
||||
* @param uri the uri to write the bitmap to, if null
|
||||
* @return the uri where the image was saved in, either the given uri or new pointing to temp
|
||||
* file.
|
||||
*/
|
||||
static Uri writeTempStateStoreBitmap(Context context, Bitmap bitmap, Uri uri) {
|
||||
try {
|
||||
boolean needSave = true;
|
||||
if (uri == null) {
|
||||
uri =
|
||||
Uri.fromFile(
|
||||
File.createTempFile("aic_state_store_temp", ".jpg", context.getCacheDir()));
|
||||
} else if (new File(uri.getPath()).exists()) {
|
||||
needSave = false;
|
||||
}
|
||||
if (needSave) {
|
||||
writeBitmapToUri(context, bitmap, uri, Bitmap.CompressFormat.JPEG, 95);
|
||||
}
|
||||
return uri;
|
||||
} catch (Exception e) {
|
||||
Log.w("AIC", "Failed to write bitmap to temp file for image-cropper save instance state", e);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Write the given bitmap to the given uri using the given compression.
|
||||
*/
|
||||
static void writeBitmapToUri(
|
||||
Context context,
|
||||
Bitmap bitmap,
|
||||
Uri uri,
|
||||
Bitmap.CompressFormat compressFormat,
|
||||
int compressQuality)
|
||||
throws FileNotFoundException {
|
||||
OutputStream outputStream = null;
|
||||
try {
|
||||
outputStream = context.getContentResolver().openOutputStream(uri);
|
||||
bitmap.compress(compressFormat, compressQuality, outputStream);
|
||||
} finally {
|
||||
closeSafe(outputStream);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Resize the given bitmap to the given width/height by the given option.<br>
|
||||
*/
|
||||
static Bitmap resizeBitmap(
|
||||
Bitmap bitmap, int reqWidth, int reqHeight, CropImageView.RequestSizeOptions options) {
|
||||
try {
|
||||
if (reqWidth > 0
|
||||
&& reqHeight > 0
|
||||
&& (options == CropImageView.RequestSizeOptions.RESIZE_FIT
|
||||
|| options == CropImageView.RequestSizeOptions.RESIZE_INSIDE
|
||||
|| options == CropImageView.RequestSizeOptions.RESIZE_EXACT)) {
|
||||
|
||||
Bitmap resized = null;
|
||||
if (options == CropImageView.RequestSizeOptions.RESIZE_EXACT) {
|
||||
resized = Bitmap.createScaledBitmap(bitmap, reqWidth, reqHeight, false);
|
||||
} else {
|
||||
int width = bitmap.getWidth();
|
||||
int height = bitmap.getHeight();
|
||||
float scale = Math.max(width / (float) reqWidth, height / (float) reqHeight);
|
||||
if (scale > 1 || options == CropImageView.RequestSizeOptions.RESIZE_FIT) {
|
||||
resized =
|
||||
Bitmap.createScaledBitmap(
|
||||
bitmap, (int) (width / scale), (int) (height / scale), false);
|
||||
}
|
||||
}
|
||||
if (resized != null) {
|
||||
if (resized != bitmap) {
|
||||
bitmap.recycle();
|
||||
}
|
||||
return resized;
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
Log.w("AIC", "Failed to resize cropped image, return bitmap before resize", e);
|
||||
}
|
||||
return bitmap;
|
||||
}
|
||||
|
||||
// region: Private methods
|
||||
|
||||
/**
|
||||
* Crop image bitmap from URI by decoding it with specific width and height to down-sample if
|
||||
* required.
|
||||
*
|
||||
* @param orgWidth used to get rectangle from points (handle edge cases to limit rectangle)
|
||||
* @param orgHeight used to get rectangle from points (handle edge cases to limit rectangle)
|
||||
* @param sampleMulti used to increase the sampling of the image to handle memory issues.
|
||||
*/
|
||||
private static BitmapSampled cropBitmap(
|
||||
Context context,
|
||||
Uri loadedImageUri,
|
||||
float[] points,
|
||||
int degreesRotated,
|
||||
int orgWidth,
|
||||
int orgHeight,
|
||||
boolean fixAspectRatio,
|
||||
int aspectRatioX,
|
||||
int aspectRatioY,
|
||||
int reqWidth,
|
||||
int reqHeight,
|
||||
boolean flipHorizontally,
|
||||
boolean flipVertically,
|
||||
int sampleMulti) {
|
||||
|
||||
// get the rectangle in original image that contains the required cropped area (larger for non
|
||||
// rectangular crop)
|
||||
Rect rect =
|
||||
getRectFromPoints(points, orgWidth, orgHeight, fixAspectRatio, aspectRatioX, aspectRatioY);
|
||||
|
||||
int width = reqWidth > 0 ? reqWidth : rect.width();
|
||||
int height = reqHeight > 0 ? reqHeight : rect.height();
|
||||
|
||||
Bitmap result = null;
|
||||
int sampleSize = 1;
|
||||
try {
|
||||
// decode only the required image from URI, optionally sub-sampling if reqWidth/reqHeight is
|
||||
// given.
|
||||
BitmapSampled bitmapSampled =
|
||||
decodeSampledBitmapRegion(context, loadedImageUri, rect, width, height, sampleMulti);
|
||||
result = bitmapSampled.bitmap;
|
||||
sampleSize = bitmapSampled.sampleSize;
|
||||
} catch (Exception ignored) {
|
||||
}
|
||||
|
||||
if (result != null) {
|
||||
try {
|
||||
// rotate the decoded region by the required amount
|
||||
result = rotateAndFlipBitmapInt(result, degreesRotated, flipHorizontally, flipVertically);
|
||||
|
||||
// rotating by 0, 90, 180 or 270 degrees doesn't require extra cropping
|
||||
if (degreesRotated % 90 != 0) {
|
||||
|
||||
// extra crop because non rectangular crop cannot be done directly on the image without
|
||||
// rotating first
|
||||
result =
|
||||
cropForRotatedImage(
|
||||
result, points, rect, degreesRotated, fixAspectRatio, aspectRatioX, aspectRatioY);
|
||||
}
|
||||
} catch (OutOfMemoryError e) {
|
||||
if (result != null) {
|
||||
result.recycle();
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
return new BitmapSampled(result, sampleSize);
|
||||
} else {
|
||||
// failed to decode region, may be skia issue, try full decode and then crop
|
||||
return cropBitmap(
|
||||
context,
|
||||
loadedImageUri,
|
||||
points,
|
||||
degreesRotated,
|
||||
fixAspectRatio,
|
||||
aspectRatioX,
|
||||
aspectRatioY,
|
||||
sampleMulti,
|
||||
rect,
|
||||
width,
|
||||
height,
|
||||
flipHorizontally,
|
||||
flipVertically);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Crop bitmap by fully loading the original and then cropping it, fallback in case cropping
|
||||
* region failed.
|
||||
*/
|
||||
private static BitmapSampled cropBitmap(
|
||||
Context context,
|
||||
Uri loadedImageUri,
|
||||
float[] points,
|
||||
int degreesRotated,
|
||||
boolean fixAspectRatio,
|
||||
int aspectRatioX,
|
||||
int aspectRatioY,
|
||||
int sampleMulti,
|
||||
Rect rect,
|
||||
int width,
|
||||
int height,
|
||||
boolean flipHorizontally,
|
||||
boolean flipVertically) {
|
||||
Bitmap result = null;
|
||||
int sampleSize;
|
||||
try {
|
||||
BitmapFactory.Options options = new BitmapFactory.Options();
|
||||
options.inSampleSize =
|
||||
sampleSize =
|
||||
sampleMulti
|
||||
* calculateInSampleSizeByReqestedSize(rect.width(), rect.height(), width, height);
|
||||
|
||||
Bitmap fullBitmap = decodeImage(context.getContentResolver(), loadedImageUri, options);
|
||||
if (fullBitmap != null) {
|
||||
try {
|
||||
// adjust crop points by the sampling because the image is smaller
|
||||
float[] points2 = new float[points.length];
|
||||
System.arraycopy(points, 0, points2, 0, points.length);
|
||||
for (int i = 0; i < points2.length; i++) {
|
||||
points2[i] = points2[i] / options.inSampleSize;
|
||||
}
|
||||
|
||||
result =
|
||||
cropBitmapObjectWithScale(
|
||||
fullBitmap,
|
||||
points2,
|
||||
degreesRotated,
|
||||
fixAspectRatio,
|
||||
aspectRatioX,
|
||||
aspectRatioY,
|
||||
1,
|
||||
flipHorizontally,
|
||||
flipVertically);
|
||||
} finally {
|
||||
if (result != fullBitmap) {
|
||||
fullBitmap.recycle();
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (OutOfMemoryError e) {
|
||||
if (result != null) {
|
||||
result.recycle();
|
||||
}
|
||||
throw e;
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(
|
||||
"Failed to load sampled bitmap: " + loadedImageUri + "\r\n" + e.getMessage(), e);
|
||||
}
|
||||
return new BitmapSampled(result, sampleSize);
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode image from uri using "inJustDecodeBounds" to get the image dimensions.
|
||||
*/
|
||||
private static BitmapFactory.Options decodeImageForOption(ContentResolver resolver, Uri uri)
|
||||
throws FileNotFoundException {
|
||||
InputStream stream = null;
|
||||
try {
|
||||
stream = resolver.openInputStream(uri);
|
||||
BitmapFactory.Options options = new BitmapFactory.Options();
|
||||
options.inJustDecodeBounds = true;
|
||||
BitmapFactory.decodeStream(stream, EMPTY_RECT, options);
|
||||
options.inJustDecodeBounds = false;
|
||||
return options;
|
||||
} finally {
|
||||
closeSafe(stream);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode image from uri using given "inSampleSize", but if failed due to out-of-memory then raise
|
||||
* the inSampleSize until success.
|
||||
*/
|
||||
private static Bitmap decodeImage(
|
||||
ContentResolver resolver, Uri uri, BitmapFactory.Options options)
|
||||
throws FileNotFoundException {
|
||||
do {
|
||||
InputStream stream = null;
|
||||
try {
|
||||
stream = resolver.openInputStream(uri);
|
||||
return BitmapFactory.decodeStream(stream, EMPTY_RECT, options);
|
||||
} catch (OutOfMemoryError e) {
|
||||
options.inSampleSize *= 2;
|
||||
} finally {
|
||||
closeSafe(stream);
|
||||
}
|
||||
} while (options.inSampleSize <= 512);
|
||||
throw new RuntimeException("Failed to decode image: " + uri);
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode specific rectangle bitmap from stream using sampling to get bitmap with the requested
|
||||
* limit.
|
||||
*
|
||||
* @param sampleMulti used to increase the sampling of the image to handle memory issues.
|
||||
*/
|
||||
private static BitmapSampled decodeSampledBitmapRegion(
|
||||
Context context, Uri uri, Rect rect, int reqWidth, int reqHeight, int sampleMulti) {
|
||||
InputStream stream = null;
|
||||
BitmapRegionDecoder decoder = null;
|
||||
try {
|
||||
BitmapFactory.Options options = new BitmapFactory.Options();
|
||||
options.inSampleSize =
|
||||
sampleMulti
|
||||
* calculateInSampleSizeByReqestedSize(
|
||||
rect.width(), rect.height(), reqWidth, reqHeight);
|
||||
|
||||
stream = context.getContentResolver().openInputStream(uri);
|
||||
decoder = BitmapRegionDecoder.newInstance(stream, false);
|
||||
do {
|
||||
try {
|
||||
return new BitmapSampled(decoder.decodeRegion(rect, options), options.inSampleSize);
|
||||
} catch (OutOfMemoryError e) {
|
||||
options.inSampleSize *= 2;
|
||||
}
|
||||
} while (options.inSampleSize <= 512);
|
||||
} catch (Exception e) {
|
||||
throw new RuntimeException(
|
||||
"Failed to load sampled bitmap: " + uri + "\r\n" + e.getMessage(), e);
|
||||
} finally {
|
||||
closeSafe(stream);
|
||||
if (decoder != null) {
|
||||
decoder.recycle();
|
||||
}
|
||||
}
|
||||
return new BitmapSampled(null, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Special crop of bitmap rotated by not stright angle, in this case the original crop bitmap
|
||||
* contains parts beyond the required crop area, this method crops the already cropped and rotated
|
||||
* bitmap to the final rectangle.<br>
|
||||
* Note: rotating by 0, 90, 180 or 270 degrees doesn't require extra cropping.
|
||||
*/
|
||||
private static Bitmap cropForRotatedImage(
|
||||
Bitmap bitmap,
|
||||
float[] points,
|
||||
Rect rect,
|
||||
int degreesRotated,
|
||||
boolean fixAspectRatio,
|
||||
int aspectRatioX,
|
||||
int aspectRatioY) {
|
||||
if (degreesRotated % 90 != 0) {
|
||||
|
||||
int adjLeft = 0, adjTop = 0, width = 0, height = 0;
|
||||
double rads = Math.toRadians(degreesRotated);
|
||||
int compareTo =
|
||||
degreesRotated < 90 || (degreesRotated > 180 && degreesRotated < 270)
|
||||
? rect.left
|
||||
: rect.right;
|
||||
for (int i = 0; i < points.length; i += 2) {
|
||||
if (points[i] >= compareTo - 1 && points[i] <= compareTo + 1) {
|
||||
adjLeft = (int) Math.abs(Math.sin(rads) * (rect.bottom - points[i + 1]));
|
||||
adjTop = (int) Math.abs(Math.cos(rads) * (points[i + 1] - rect.top));
|
||||
width = (int) Math.abs((points[i + 1] - rect.top) / Math.sin(rads));
|
||||
height = (int) Math.abs((rect.bottom - points[i + 1]) / Math.cos(rads));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
rect.set(adjLeft, adjTop, adjLeft + width, adjTop + height);
|
||||
if (fixAspectRatio) {
|
||||
fixRectForAspectRatio(rect, aspectRatioX, aspectRatioY);
|
||||
}
|
||||
|
||||
Bitmap bitmapTmp = bitmap;
|
||||
bitmap = Bitmap.createBitmap(bitmap, rect.left, rect.top, rect.width(), rect.height());
|
||||
if (bitmapTmp != bitmap) {
|
||||
bitmapTmp.recycle();
|
||||
}
|
||||
}
|
||||
return bitmap;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate the largest inSampleSize value that is a power of 2 and keeps both height and width
|
||||
* larger than the requested height and width.
|
||||
*/
|
||||
private static int calculateInSampleSizeByReqestedSize(
|
||||
int width, int height, int reqWidth, int reqHeight) {
|
||||
int inSampleSize = 1;
|
||||
if (height > reqHeight || width > reqWidth) {
|
||||
while ((height / 2 / inSampleSize) > reqHeight && (width / 2 / inSampleSize) > reqWidth) {
|
||||
inSampleSize *= 2;
|
||||
}
|
||||
}
|
||||
return inSampleSize;
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate the largest inSampleSize value that is a power of 2 and keeps both height and width
|
||||
* smaller than max texture size allowed for the device.
|
||||
*/
|
||||
private static int calculateInSampleSizeByMaxTextureSize(int width, int height) {
|
||||
int inSampleSize = 1;
|
||||
if (mMaxTextureSize == 0) {
|
||||
mMaxTextureSize = getMaxTextureSize();
|
||||
}
|
||||
if (mMaxTextureSize > 0) {
|
||||
while ((height / inSampleSize) > mMaxTextureSize
|
||||
|| (width / inSampleSize) > mMaxTextureSize) {
|
||||
inSampleSize *= 2;
|
||||
}
|
||||
}
|
||||
return inSampleSize;
|
||||
}
|
||||
|
||||
/**
|
||||
* Rotate the given bitmap by the given degrees.<br>
|
||||
* New bitmap is created and the old one is recycled.
|
||||
*/
|
||||
private static Bitmap rotateAndFlipBitmapInt(
|
||||
Bitmap bitmap, int degrees, boolean flipHorizontally, boolean flipVertically) {
|
||||
if (degrees > 0 || flipHorizontally || flipVertically) {
|
||||
Matrix matrix = new Matrix();
|
||||
matrix.setRotate(degrees);
|
||||
matrix.postScale(flipHorizontally ? -1 : 1, flipVertically ? -1 : 1);
|
||||
Bitmap newBitmap =
|
||||
Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, false);
|
||||
if (newBitmap != bitmap) {
|
||||
bitmap.recycle();
|
||||
}
|
||||
return newBitmap;
|
||||
} else {
|
||||
return bitmap;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the max size of bitmap allowed to be rendered on the device.<br>
|
||||
* http://stackoverflow.com/questions/7428996/hw-accelerated-activity-how-to-get-opengl-texture-size-limit.
|
||||
*/
|
||||
private static int getMaxTextureSize() {
|
||||
// Safe minimum default size
|
||||
final int IMAGE_MAX_BITMAP_DIMENSION = 2048;
|
||||
|
||||
try {
|
||||
// Get EGL Display
|
||||
EGL10 egl = (EGL10) EGLContext.getEGL();
|
||||
EGLDisplay display = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
|
||||
|
||||
// Initialise
|
||||
int[] version = new int[2];
|
||||
egl.eglInitialize(display, version);
|
||||
|
||||
// Query total number of configurations
|
||||
int[] totalConfigurations = new int[1];
|
||||
egl.eglGetConfigs(display, null, 0, totalConfigurations);
|
||||
|
||||
// Query actual list configurations
|
||||
EGLConfig[] configurationsList = new EGLConfig[totalConfigurations[0]];
|
||||
egl.eglGetConfigs(display, configurationsList, totalConfigurations[0], totalConfigurations);
|
||||
|
||||
int[] textureSize = new int[1];
|
||||
int maximumTextureSize = 0;
|
||||
|
||||
// Iterate through all the configurations to located the maximum texture size
|
||||
for (int i = 0; i < totalConfigurations[0]; i++) {
|
||||
// Only need to check for width since opengl textures are always squared
|
||||
egl.eglGetConfigAttrib(
|
||||
display, configurationsList[i], EGL10.EGL_MAX_PBUFFER_WIDTH, textureSize);
|
||||
|
||||
// Keep track of the maximum texture size
|
||||
if (maximumTextureSize < textureSize[0]) {
|
||||
maximumTextureSize = textureSize[0];
|
||||
}
|
||||
}
|
||||
|
||||
// Release
|
||||
egl.eglTerminate(display);
|
||||
|
||||
// Return largest texture size found, or default
|
||||
return Math.max(maximumTextureSize, IMAGE_MAX_BITMAP_DIMENSION);
|
||||
} catch (Exception e) {
|
||||
return IMAGE_MAX_BITMAP_DIMENSION;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Close the given closeable object (Stream) in a safe way: check if it is null and catch-log
|
||||
* exception thrown.
|
||||
*
|
||||
* @param closeable the closable object to close
|
||||
*/
|
||||
private static void closeSafe(Closeable closeable) {
|
||||
if (closeable != null) {
|
||||
try {
|
||||
closeable.close();
|
||||
} catch (IOException ignored) {
|
||||
}
|
||||
}
|
||||
}
|
||||
// endregion
|
||||
|
||||
// region: Inner class: BitmapSampled
|
||||
|
||||
/**
|
||||
* Holds bitmap instance and the sample size that the bitmap was loaded/cropped with.
|
||||
*/
|
||||
static final class BitmapSampled {
|
||||
|
||||
/**
|
||||
* The bitmap instance
|
||||
*/
|
||||
public final Bitmap bitmap;
|
||||
|
||||
/**
|
||||
* The sample size used to lower the size of the bitmap (1,2,4,8,...)
|
||||
*/
|
||||
final int sampleSize;
|
||||
|
||||
BitmapSampled(Bitmap bitmap, int sampleSize) {
|
||||
this.bitmap = bitmap;
|
||||
this.sampleSize = sampleSize;
|
||||
}
|
||||
}
|
||||
// endregion
|
||||
|
||||
// region: Inner class: RotateBitmapResult
|
||||
|
||||
/**
|
||||
* The result of {@link #rotateBitmapByExif(android.graphics.Bitmap, ExifInterface)}.
|
||||
*/
|
||||
static final class RotateBitmapResult {
|
||||
|
||||
/**
|
||||
* The loaded bitmap
|
||||
*/
|
||||
public final Bitmap bitmap;
|
||||
|
||||
/**
|
||||
* The degrees the image was rotated
|
||||
*/
|
||||
final int degrees;
|
||||
|
||||
RotateBitmapResult(Bitmap bitmap, int degrees) {
|
||||
this.bitmap = bitmap;
|
||||
this.degrees = degrees;
|
||||
}
|
||||
}
|
||||
// endregion
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,367 +0,0 @@
|
||||
// "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.theartofdev.edmodo.cropper;
|
||||
|
||||
import android.Manifest;
|
||||
import android.annotation.SuppressLint;
|
||||
import android.app.Activity;
|
||||
import android.content.Intent;
|
||||
import android.content.pm.PackageManager;
|
||||
import android.graphics.Bitmap;
|
||||
import android.graphics.PorterDuff;
|
||||
import android.graphics.drawable.Drawable;
|
||||
import android.net.Uri;
|
||||
import android.os.Bundle;
|
||||
import android.view.Menu;
|
||||
import android.view.MenuItem;
|
||||
import android.widget.Toast;
|
||||
|
||||
import androidx.annotation.NonNull;
|
||||
import androidx.appcompat.app.ActionBar;
|
||||
import androidx.appcompat.app.AppCompatActivity;
|
||||
import androidx.core.content.ContextCompat;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* Built-in activity for image cropping.<br>
|
||||
* Use {@link CropImage#activity(Uri)} to create a builder to start this activity.
|
||||
*/
|
||||
public class CropImageActivity extends AppCompatActivity
|
||||
implements CropImageView.OnSetImageUriCompleteListener,
|
||||
CropImageView.OnCropImageCompleteListener {
|
||||
|
||||
/**
|
||||
* The crop image view library widget used in the activity
|
||||
*/
|
||||
private CropImageView mCropImageView;
|
||||
|
||||
/**
|
||||
* Persist URI image to crop URI if specific permissions are required
|
||||
*/
|
||||
private Uri mCropImageUri;
|
||||
|
||||
/**
|
||||
* the options that were set for the crop image
|
||||
*/
|
||||
private CropImageOptions mOptions;
|
||||
|
||||
@Override
|
||||
@SuppressLint("NewApi")
|
||||
public void onCreate(Bundle savedInstanceState) {
|
||||
super.onCreate(savedInstanceState);
|
||||
setContentView(R.layout.crop_image_activity);
|
||||
|
||||
mCropImageView = findViewById(R.id.cropImageView);
|
||||
|
||||
Bundle bundle = getIntent().getBundleExtra(CropImage.CROP_IMAGE_EXTRA_BUNDLE);
|
||||
mCropImageUri = bundle.getParcelable(CropImage.CROP_IMAGE_EXTRA_SOURCE);
|
||||
mOptions = bundle.getParcelable(CropImage.CROP_IMAGE_EXTRA_OPTIONS);
|
||||
|
||||
if (savedInstanceState == null) {
|
||||
if (mCropImageUri == null || mCropImageUri.equals(Uri.EMPTY)) {
|
||||
if (CropImage.isExplicitCameraPermissionRequired(this)) {
|
||||
// request permissions and handle the result in onRequestPermissionsResult()
|
||||
requestPermissions(
|
||||
new String[]{Manifest.permission.CAMERA},
|
||||
CropImage.CAMERA_CAPTURE_PERMISSIONS_REQUEST_CODE);
|
||||
} else {
|
||||
CropImage.startPickImageActivity(this);
|
||||
}
|
||||
} else if (CropImage.isReadExternalStoragePermissionsRequired(this, mCropImageUri)) {
|
||||
// request permissions and handle the result in onRequestPermissionsResult()
|
||||
requestPermissions(
|
||||
new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
|
||||
CropImage.PICK_IMAGE_PERMISSIONS_REQUEST_CODE);
|
||||
} else {
|
||||
// no permissions required or already grunted, can start crop image activity
|
||||
mCropImageView.setImageUriAsync(mCropImageUri);
|
||||
}
|
||||
}
|
||||
|
||||
ActionBar actionBar = getSupportActionBar();
|
||||
if (actionBar != null) {
|
||||
CharSequence title = mOptions != null &&
|
||||
mOptions.activityTitle != null && mOptions.activityTitle.length() > 0
|
||||
? mOptions.activityTitle
|
||||
: getResources().getString(R.string.crop_image_activity_title);
|
||||
actionBar.setTitle(title);
|
||||
actionBar.setDisplayHomeAsUpEnabled(true);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onStart() {
|
||||
super.onStart();
|
||||
mCropImageView.setOnSetImageUriCompleteListener(this);
|
||||
mCropImageView.setOnCropImageCompleteListener(this);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void onStop() {
|
||||
super.onStop();
|
||||
mCropImageView.setOnSetImageUriCompleteListener(null);
|
||||
mCropImageView.setOnCropImageCompleteListener(null);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean onCreateOptionsMenu(Menu menu) {
|
||||
getMenuInflater().inflate(R.menu.crop_image_menu, menu);
|
||||
|
||||
if (!mOptions.allowRotation) {
|
||||
menu.removeItem(R.id.crop_image_menu_rotate_left);
|
||||
menu.removeItem(R.id.crop_image_menu_rotate_right);
|
||||
} else if (mOptions.allowCounterRotation) {
|
||||
menu.findItem(R.id.crop_image_menu_rotate_left).setVisible(true);
|
||||
}
|
||||
|
||||
if (!mOptions.allowFlipping) {
|
||||
menu.removeItem(R.id.crop_image_menu_flip);
|
||||
}
|
||||
|
||||
if (mOptions.cropMenuCropButtonTitle != null) {
|
||||
menu.findItem(R.id.crop_image_menu_crop).setTitle(mOptions.cropMenuCropButtonTitle);
|
||||
}
|
||||
|
||||
Drawable cropIcon = null;
|
||||
try {
|
||||
if (mOptions.cropMenuCropButtonIcon != 0) {
|
||||
cropIcon = ContextCompat.getDrawable(this, mOptions.cropMenuCropButtonIcon);
|
||||
menu.findItem(R.id.crop_image_menu_crop).setIcon(cropIcon);
|
||||
}
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
if (mOptions.activityMenuIconColor != 0) {
|
||||
updateMenuItemIconColor(
|
||||
menu, R.id.crop_image_menu_rotate_left, mOptions.activityMenuIconColor);
|
||||
updateMenuItemIconColor(
|
||||
menu, R.id.crop_image_menu_rotate_right, mOptions.activityMenuIconColor);
|
||||
updateMenuItemIconColor(menu, R.id.crop_image_menu_flip, mOptions.activityMenuIconColor);
|
||||
if (cropIcon != null) {
|
||||
updateMenuItemIconColor(menu, R.id.crop_image_menu_crop, mOptions.activityMenuIconColor);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean onOptionsItemSelected(MenuItem item) {
|
||||
if (item.getItemId() == R.id.crop_image_menu_crop) {
|
||||
cropImage();
|
||||
return true;
|
||||
}
|
||||
if (item.getItemId() == R.id.crop_image_menu_rotate_left) {
|
||||
rotateImage(-mOptions.rotationDegrees);
|
||||
return true;
|
||||
}
|
||||
if (item.getItemId() == R.id.crop_image_menu_rotate_right) {
|
||||
rotateImage(mOptions.rotationDegrees);
|
||||
return true;
|
||||
}
|
||||
if (item.getItemId() == R.id.crop_image_menu_flip_horizontally) {
|
||||
mCropImageView.flipImageHorizontally();
|
||||
return true;
|
||||
}
|
||||
if (item.getItemId() == R.id.crop_image_menu_flip_vertically) {
|
||||
mCropImageView.flipImageVertically();
|
||||
return true;
|
||||
}
|
||||
if (item.getItemId() == android.R.id.home) {
|
||||
setResultCancel();
|
||||
return true;
|
||||
}
|
||||
return super.onOptionsItemSelected(item);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onBackPressed() {
|
||||
super.onBackPressed();
|
||||
setResultCancel();
|
||||
}
|
||||
|
||||
@Override
|
||||
@SuppressLint("NewApi")
|
||||
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
|
||||
|
||||
// handle result of pick image chooser
|
||||
if (requestCode == CropImage.PICK_IMAGE_CHOOSER_REQUEST_CODE) {
|
||||
if (resultCode == Activity.RESULT_CANCELED) {
|
||||
// User cancelled the picker. We don't have anything to crop
|
||||
setResultCancel();
|
||||
}
|
||||
|
||||
if (resultCode == Activity.RESULT_OK) {
|
||||
mCropImageUri = CropImage.getPickImageResultUri(this, data);
|
||||
|
||||
// For API >= 23 we need to check specifically that we have permissions to read external
|
||||
// storage.
|
||||
if (CropImage.isReadExternalStoragePermissionsRequired(this, mCropImageUri)) {
|
||||
// request permissions and handle the result in onRequestPermissionsResult()
|
||||
requestPermissions(
|
||||
new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
|
||||
CropImage.PICK_IMAGE_PERMISSIONS_REQUEST_CODE);
|
||||
} else {
|
||||
// no permissions required or already grunted, can start crop image activity
|
||||
mCropImageView.setImageUriAsync(mCropImageUri);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onRequestPermissionsResult(
|
||||
int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
|
||||
if (requestCode == CropImage.PICK_IMAGE_PERMISSIONS_REQUEST_CODE) {
|
||||
if (mCropImageUri != null
|
||||
&& grantResults.length > 0
|
||||
&& grantResults[0] == PackageManager.PERMISSION_GRANTED) {
|
||||
// required permissions granted, start crop image activity
|
||||
mCropImageView.setImageUriAsync(mCropImageUri);
|
||||
} else {
|
||||
Toast.makeText(this, R.string.crop_image_activity_no_permissions, Toast.LENGTH_LONG).show();
|
||||
setResultCancel();
|
||||
}
|
||||
}
|
||||
|
||||
if (requestCode == CropImage.CAMERA_CAPTURE_PERMISSIONS_REQUEST_CODE) {
|
||||
// Irrespective of whether camera permission was given or not, we show the picker
|
||||
// The picker will not add the camera intent if permission is not available
|
||||
CropImage.startPickImageActivity(this);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onSetImageUriComplete(CropImageView view, Uri uri, Exception error) {
|
||||
if (error == null) {
|
||||
if (mOptions.initialCropWindowRectangle != null) {
|
||||
mCropImageView.setCropRect(mOptions.initialCropWindowRectangle);
|
||||
}
|
||||
if (mOptions.initialRotation > -1) {
|
||||
mCropImageView.setRotatedDegrees(mOptions.initialRotation);
|
||||
}
|
||||
} else {
|
||||
setResult(null, error, 1);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onCropImageComplete(CropImageView view, CropImageView.CropResult result) {
|
||||
setResult(result.getUri(), result.getError(), result.getSampleSize());
|
||||
}
|
||||
|
||||
// region: Private methods
|
||||
|
||||
/**
|
||||
* Execute crop image and save the result tou output uri.
|
||||
*/
|
||||
protected void cropImage() {
|
||||
if (mOptions.noOutputImage) {
|
||||
setResult(null, null, 1);
|
||||
} else {
|
||||
Uri outputUri = getOutputUri();
|
||||
mCropImageView.saveCroppedImageAsync(
|
||||
outputUri,
|
||||
mOptions.outputCompressFormat,
|
||||
mOptions.outputCompressQuality,
|
||||
mOptions.outputRequestWidth,
|
||||
mOptions.outputRequestHeight,
|
||||
mOptions.outputRequestSizeOptions);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Rotate the image in the crop image view.
|
||||
*/
|
||||
protected void rotateImage(int degrees) {
|
||||
mCropImageView.rotateImage(degrees);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Android uri to save the cropped image into.<br>
|
||||
* Use the given in options or create a temp file.
|
||||
*/
|
||||
protected Uri getOutputUri() {
|
||||
Uri outputUri = mOptions.outputUri;
|
||||
if (outputUri == null || outputUri.equals(Uri.EMPTY)) {
|
||||
try {
|
||||
String ext =
|
||||
mOptions.outputCompressFormat == Bitmap.CompressFormat.JPEG
|
||||
? ".jpg"
|
||||
: mOptions.outputCompressFormat == Bitmap.CompressFormat.PNG ? ".png" : ".webp";
|
||||
outputUri = Uri.fromFile(File.createTempFile("cropped", ext, getCacheDir()));
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException("Failed to create temp file for output image", e);
|
||||
}
|
||||
}
|
||||
return outputUri;
|
||||
}
|
||||
|
||||
/**
|
||||
* Result with cropped image data or error if failed.
|
||||
*/
|
||||
protected void setResult(Uri uri, Exception error, int sampleSize) {
|
||||
int resultCode = error == null ? RESULT_OK : CropImage.CROP_IMAGE_ACTIVITY_RESULT_ERROR_CODE;
|
||||
setResult(resultCode, getResultIntent(uri, error, sampleSize));
|
||||
finish();
|
||||
}
|
||||
|
||||
/**
|
||||
* Cancel of cropping activity.
|
||||
*/
|
||||
protected void setResultCancel() {
|
||||
setResult(RESULT_CANCELED);
|
||||
finish();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get intent instance to be used for the result of this activity.
|
||||
*/
|
||||
protected Intent getResultIntent(Uri uri, Exception error, int sampleSize) {
|
||||
CropImage.ActivityResult result =
|
||||
new CropImage.ActivityResult(
|
||||
mCropImageView.getImageUri(),
|
||||
uri,
|
||||
error,
|
||||
mCropImageView.getCropPoints(),
|
||||
mCropImageView.getCropRect(),
|
||||
mCropImageView.getRotatedDegrees(),
|
||||
mCropImageView.getWholeImageRect(),
|
||||
sampleSize);
|
||||
Intent intent = new Intent();
|
||||
intent.putExtras(getIntent());
|
||||
intent.putExtra(CropImage.CROP_IMAGE_EXTRA_RESULT, result);
|
||||
return intent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Update the color of a specific menu item to the given color.
|
||||
*/
|
||||
private void updateMenuItemIconColor(Menu menu, int itemId, int color) {
|
||||
MenuItem menuItem = menu.findItem(itemId);
|
||||
if (menuItem != null) {
|
||||
Drawable menuItemIcon = menuItem.getIcon();
|
||||
if (menuItemIcon != null) {
|
||||
try {
|
||||
menuItemIcon.mutate();
|
||||
menuItemIcon.setColorFilter(color, PorterDuff.Mode.SRC_ATOP);
|
||||
menuItem.setIcon(menuItemIcon);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,123 +0,0 @@
|
||||
// "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.theartofdev.edmodo.cropper;
|
||||
|
||||
import android.graphics.Matrix;
|
||||
import android.graphics.RectF;
|
||||
import android.view.animation.AccelerateDecelerateInterpolator;
|
||||
import android.view.animation.Animation;
|
||||
import android.view.animation.Transformation;
|
||||
import android.widget.ImageView;
|
||||
|
||||
/**
|
||||
* Animation to handle smooth cropping image matrix transformation change, specifically for
|
||||
* zoom-in/out.
|
||||
*/
|
||||
final class CropImageAnimation extends Animation implements Animation.AnimationListener {
|
||||
|
||||
// region: Fields and Consts
|
||||
|
||||
private final ImageView mImageView;
|
||||
|
||||
private final CropOverlayView mCropOverlayView;
|
||||
|
||||
private final float[] mStartBoundPoints = new float[8];
|
||||
|
||||
private final float[] mEndBoundPoints = new float[8];
|
||||
|
||||
private final RectF mStartCropWindowRect = new RectF();
|
||||
|
||||
private final RectF mEndCropWindowRect = new RectF();
|
||||
|
||||
private final float[] mStartImageMatrix = new float[9];
|
||||
|
||||
private final float[] mEndImageMatrix = new float[9];
|
||||
|
||||
private final RectF mAnimRect = new RectF();
|
||||
|
||||
private final float[] mAnimPoints = new float[8];
|
||||
|
||||
private final float[] mAnimMatrix = new float[9];
|
||||
// endregion
|
||||
|
||||
public CropImageAnimation(ImageView cropImageView, CropOverlayView cropOverlayView) {
|
||||
mImageView = cropImageView;
|
||||
mCropOverlayView = cropOverlayView;
|
||||
|
||||
setDuration(300);
|
||||
setFillAfter(true);
|
||||
setInterpolator(new AccelerateDecelerateInterpolator());
|
||||
setAnimationListener(this);
|
||||
}
|
||||
|
||||
public void setStartState(float[] boundPoints, Matrix imageMatrix) {
|
||||
reset();
|
||||
System.arraycopy(boundPoints, 0, mStartBoundPoints, 0, 8);
|
||||
mStartCropWindowRect.set(mCropOverlayView.getCropWindowRect());
|
||||
imageMatrix.getValues(mStartImageMatrix);
|
||||
}
|
||||
|
||||
public void setEndState(float[] boundPoints, Matrix imageMatrix) {
|
||||
System.arraycopy(boundPoints, 0, mEndBoundPoints, 0, 8);
|
||||
mEndCropWindowRect.set(mCropOverlayView.getCropWindowRect());
|
||||
imageMatrix.getValues(mEndImageMatrix);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void applyTransformation(float interpolatedTime, Transformation t) {
|
||||
|
||||
mAnimRect.left =
|
||||
mStartCropWindowRect.left
|
||||
+ (mEndCropWindowRect.left - mStartCropWindowRect.left) * interpolatedTime;
|
||||
mAnimRect.top =
|
||||
mStartCropWindowRect.top
|
||||
+ (mEndCropWindowRect.top - mStartCropWindowRect.top) * interpolatedTime;
|
||||
mAnimRect.right =
|
||||
mStartCropWindowRect.right
|
||||
+ (mEndCropWindowRect.right - mStartCropWindowRect.right) * interpolatedTime;
|
||||
mAnimRect.bottom =
|
||||
mStartCropWindowRect.bottom
|
||||
+ (mEndCropWindowRect.bottom - mStartCropWindowRect.bottom) * interpolatedTime;
|
||||
mCropOverlayView.setCropWindowRect(mAnimRect);
|
||||
|
||||
for (int i = 0; i < mAnimPoints.length; i++) {
|
||||
mAnimPoints[i] =
|
||||
mStartBoundPoints[i] + (mEndBoundPoints[i] - mStartBoundPoints[i]) * interpolatedTime;
|
||||
}
|
||||
mCropOverlayView.setBounds(mAnimPoints, mImageView.getWidth(), mImageView.getHeight());
|
||||
|
||||
for (int i = 0; i < mAnimMatrix.length; i++) {
|
||||
mAnimMatrix[i] =
|
||||
mStartImageMatrix[i] + (mEndImageMatrix[i] - mStartImageMatrix[i]) * interpolatedTime;
|
||||
}
|
||||
Matrix m = mImageView.getImageMatrix();
|
||||
m.setValues(mAnimMatrix);
|
||||
mImageView.setImageMatrix(m);
|
||||
|
||||
mImageView.invalidate();
|
||||
mCropOverlayView.invalidate();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onAnimationStart(Animation animation) {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onAnimationEnd(Animation animation) {
|
||||
mImageView.clearAnimation();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onAnimationRepeat(Animation animation) {
|
||||
}
|
||||
}
|
||||
@ -1,541 +0,0 @@
|
||||
// "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.theartofdev.edmodo.cropper;
|
||||
|
||||
import android.content.res.Resources;
|
||||
import android.graphics.Bitmap;
|
||||
import android.graphics.Color;
|
||||
import android.graphics.Rect;
|
||||
import android.net.Uri;
|
||||
import android.os.Parcel;
|
||||
import android.os.Parcelable;
|
||||
import android.text.TextUtils;
|
||||
import android.util.DisplayMetrics;
|
||||
import android.util.TypedValue;
|
||||
|
||||
/**
|
||||
* All the possible options that can be set to customize crop image.<br>
|
||||
* Initialized with default values.
|
||||
*/
|
||||
public class CropImageOptions implements Parcelable {
|
||||
|
||||
public static final Creator<CropImageOptions> CREATOR =
|
||||
new Creator<CropImageOptions>() {
|
||||
@Override
|
||||
public CropImageOptions createFromParcel(Parcel in) {
|
||||
return new CropImageOptions(in);
|
||||
}
|
||||
|
||||
@Override
|
||||
public CropImageOptions[] newArray(int size) {
|
||||
return new CropImageOptions[size];
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The shape of the cropping window.
|
||||
*/
|
||||
public CropImageView.CropShape cropShape;
|
||||
|
||||
/**
|
||||
* 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. (in pixels)
|
||||
*/
|
||||
public float snapRadius;
|
||||
|
||||
/**
|
||||
* The radius of the touchable area around the handle. (in pixels)<br>
|
||||
* We are basing this value off of the recommended 48dp Rhythm.<br>
|
||||
* See: http://developer.android.com/design/style/metrics-grids.html#48dp-rhythm
|
||||
*/
|
||||
public float touchRadius;
|
||||
|
||||
/**
|
||||
* whether the guidelines should be on, off, or only showing when resizing.
|
||||
*/
|
||||
public CropImageView.Guidelines guidelines;
|
||||
|
||||
/**
|
||||
* The initial scale type of the image in the crop image view
|
||||
*/
|
||||
public CropImageView.ScaleType scaleType;
|
||||
|
||||
/**
|
||||
* if to show crop overlay UI what contains the crop window UI surrounded by background over the
|
||||
* cropping image.<br>
|
||||
* default: true, may disable for animation or frame transition.
|
||||
*/
|
||||
public boolean showCropOverlay;
|
||||
|
||||
/**
|
||||
* 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 showProgressBar;
|
||||
|
||||
/**
|
||||
* if auto-zoom functionality is enabled.<br>
|
||||
* default: true.
|
||||
*/
|
||||
public boolean autoZoomEnabled;
|
||||
|
||||
/**
|
||||
* if multi-touch should be enabled on the crop box default: false
|
||||
*/
|
||||
public boolean multiTouchEnabled;
|
||||
|
||||
/**
|
||||
* The max zoom allowed during cropping.
|
||||
*/
|
||||
public int maxZoom;
|
||||
|
||||
/**
|
||||
* The initial crop window padding from image borders in percentage of the cropping image
|
||||
* dimensions.
|
||||
*/
|
||||
public float initialCropWindowPaddingRatio;
|
||||
|
||||
/**
|
||||
* whether the width to height aspect ratio should be maintained or free to change.
|
||||
*/
|
||||
public boolean fixAspectRatio;
|
||||
|
||||
/**
|
||||
* the X value of the aspect ratio.
|
||||
*/
|
||||
public int aspectRatioX;
|
||||
|
||||
/**
|
||||
* the Y value of the aspect ratio.
|
||||
*/
|
||||
public int aspectRatioY;
|
||||
|
||||
/**
|
||||
* the thickness of the guidelines lines in pixels. (in pixels)
|
||||
*/
|
||||
public float borderLineThickness;
|
||||
|
||||
/**
|
||||
* the color of the guidelines lines
|
||||
*/
|
||||
public int borderLineColor;
|
||||
|
||||
/**
|
||||
* thickness of the corner line. (in pixels)
|
||||
*/
|
||||
public float borderCornerThickness;
|
||||
|
||||
/**
|
||||
* the offset of corner line from crop window border. (in pixels)
|
||||
*/
|
||||
public float borderCornerOffset;
|
||||
|
||||
/**
|
||||
* the length of the corner line away from the corner. (in pixels)
|
||||
*/
|
||||
public float borderCornerLength;
|
||||
|
||||
/**
|
||||
* the color of the corner line
|
||||
*/
|
||||
public int borderCornerColor;
|
||||
|
||||
/**
|
||||
* the thickness of the guidelines lines. (in pixels)
|
||||
*/
|
||||
public float guidelinesThickness;
|
||||
|
||||
/**
|
||||
* the color of the guidelines lines
|
||||
*/
|
||||
public int guidelinesColor;
|
||||
|
||||
/**
|
||||
* the color of the overlay background around the crop window cover the image parts not in the
|
||||
* crop window.
|
||||
*/
|
||||
public int backgroundColor;
|
||||
|
||||
/**
|
||||
* the min width the crop window is allowed to be. (in pixels)
|
||||
*/
|
||||
public int minCropWindowWidth;
|
||||
|
||||
/**
|
||||
* the min height the crop window is allowed to be. (in pixels)
|
||||
*/
|
||||
public int minCropWindowHeight;
|
||||
|
||||
/**
|
||||
* the min width the resulting cropping image is allowed to be, affects the cropping window
|
||||
* limits. (in pixels)
|
||||
*/
|
||||
public int minCropResultWidth;
|
||||
|
||||
/**
|
||||
* the min height the resulting cropping image is allowed to be, affects the cropping window
|
||||
* limits. (in pixels)
|
||||
*/
|
||||
public int minCropResultHeight;
|
||||
|
||||
/**
|
||||
* the max width the resulting cropping image is allowed to be, affects the cropping window
|
||||
* limits. (in pixels)
|
||||
*/
|
||||
public int maxCropResultWidth;
|
||||
|
||||
/**
|
||||
* the max height the resulting cropping image is allowed to be, affects the cropping window
|
||||
* limits. (in pixels)
|
||||
*/
|
||||
public int maxCropResultHeight;
|
||||
|
||||
/**
|
||||
* the title of the {@link CropImageActivity}
|
||||
*/
|
||||
public CharSequence activityTitle;
|
||||
|
||||
/**
|
||||
* the color to use for action bar items icons
|
||||
*/
|
||||
public int activityMenuIconColor;
|
||||
|
||||
/**
|
||||
* the Android Uri to save the cropped image to
|
||||
*/
|
||||
public Uri outputUri;
|
||||
|
||||
/**
|
||||
* the compression format to use when writing the image
|
||||
*/
|
||||
public Bitmap.CompressFormat outputCompressFormat;
|
||||
|
||||
/**
|
||||
* the quality (if applicable) to use when writing the image (0 - 100)
|
||||
*/
|
||||
public int outputCompressQuality;
|
||||
|
||||
/**
|
||||
* the width to resize the cropped image to (see options)
|
||||
*/
|
||||
public int outputRequestWidth;
|
||||
|
||||
/**
|
||||
* the height to resize the cropped image to (see options)
|
||||
*/
|
||||
public int outputRequestHeight;
|
||||
|
||||
/**
|
||||
* the resize method to use on the cropped bitmap (see options documentation)
|
||||
*/
|
||||
public CropImageView.RequestSizeOptions outputRequestSizeOptions;
|
||||
|
||||
/**
|
||||
* if the result of crop image activity should not save the cropped image bitmap
|
||||
*/
|
||||
public boolean noOutputImage;
|
||||
|
||||
/**
|
||||
* the initial rectangle to set on the cropping image after loading
|
||||
*/
|
||||
public Rect initialCropWindowRectangle;
|
||||
|
||||
/**
|
||||
* the initial rotation to set on the cropping image after loading (0-360 degrees clockwise)
|
||||
*/
|
||||
public int initialRotation;
|
||||
|
||||
/**
|
||||
* if to allow (all) rotation during cropping (activity)
|
||||
*/
|
||||
public boolean allowRotation;
|
||||
|
||||
/**
|
||||
* if to allow (all) flipping during cropping (activity)
|
||||
*/
|
||||
public boolean allowFlipping;
|
||||
|
||||
/**
|
||||
* if to allow counter-clockwise rotation during cropping (activity)
|
||||
*/
|
||||
public boolean allowCounterRotation;
|
||||
|
||||
/**
|
||||
* the amount of degrees to rotate clockwise or counter-clockwise
|
||||
*/
|
||||
public int rotationDegrees;
|
||||
|
||||
/**
|
||||
* whether the image should be flipped horizontally
|
||||
*/
|
||||
public boolean flipHorizontally;
|
||||
|
||||
/**
|
||||
* whether the image should be flipped vertically
|
||||
*/
|
||||
public boolean flipVertically;
|
||||
|
||||
/**
|
||||
* optional, the text of the crop menu crop button
|
||||
*/
|
||||
public CharSequence cropMenuCropButtonTitle;
|
||||
|
||||
/**
|
||||
* optional image resource to be used for crop menu crop icon instead of text
|
||||
*/
|
||||
public int cropMenuCropButtonIcon;
|
||||
|
||||
/**
|
||||
* Init options with defaults.
|
||||
*/
|
||||
public CropImageOptions() {
|
||||
|
||||
DisplayMetrics dm = Resources.getSystem().getDisplayMetrics();
|
||||
|
||||
cropShape = CropImageView.CropShape.RECTANGLE;
|
||||
snapRadius = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 3, dm);
|
||||
touchRadius = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 24, dm);
|
||||
guidelines = CropImageView.Guidelines.ON_TOUCH;
|
||||
scaleType = CropImageView.ScaleType.FIT_CENTER;
|
||||
showCropOverlay = true;
|
||||
showProgressBar = true;
|
||||
autoZoomEnabled = true;
|
||||
multiTouchEnabled = false;
|
||||
maxZoom = 4;
|
||||
initialCropWindowPaddingRatio = 0.1f;
|
||||
|
||||
fixAspectRatio = false;
|
||||
aspectRatioX = 1;
|
||||
aspectRatioY = 1;
|
||||
|
||||
borderLineThickness = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 3, dm);
|
||||
borderLineColor = Color.argb(170, 255, 255, 255);
|
||||
borderCornerThickness = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 2, dm);
|
||||
borderCornerOffset = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 5, dm);
|
||||
borderCornerLength = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 14, dm);
|
||||
borderCornerColor = Color.WHITE;
|
||||
|
||||
guidelinesThickness = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 1, dm);
|
||||
guidelinesColor = Color.argb(170, 255, 255, 255);
|
||||
backgroundColor = Color.argb(119, 0, 0, 0);
|
||||
|
||||
minCropWindowWidth = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 42, dm);
|
||||
minCropWindowHeight = (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 42, dm);
|
||||
minCropResultWidth = 40;
|
||||
minCropResultHeight = 40;
|
||||
maxCropResultWidth = 99999;
|
||||
maxCropResultHeight = 99999;
|
||||
|
||||
activityTitle = "";
|
||||
activityMenuIconColor = 0;
|
||||
|
||||
outputUri = Uri.EMPTY;
|
||||
outputCompressFormat = Bitmap.CompressFormat.JPEG;
|
||||
outputCompressQuality = 90;
|
||||
outputRequestWidth = 0;
|
||||
outputRequestHeight = 0;
|
||||
outputRequestSizeOptions = CropImageView.RequestSizeOptions.NONE;
|
||||
noOutputImage = false;
|
||||
|
||||
initialCropWindowRectangle = null;
|
||||
initialRotation = -1;
|
||||
allowRotation = true;
|
||||
allowFlipping = true;
|
||||
allowCounterRotation = false;
|
||||
rotationDegrees = 90;
|
||||
flipHorizontally = false;
|
||||
flipVertically = false;
|
||||
cropMenuCropButtonTitle = null;
|
||||
|
||||
cropMenuCropButtonIcon = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create object from parcel.
|
||||
*/
|
||||
protected CropImageOptions(Parcel in) {
|
||||
cropShape = CropImageView.CropShape.values()[in.readInt()];
|
||||
snapRadius = in.readFloat();
|
||||
touchRadius = in.readFloat();
|
||||
guidelines = CropImageView.Guidelines.values()[in.readInt()];
|
||||
scaleType = CropImageView.ScaleType.values()[in.readInt()];
|
||||
showCropOverlay = in.readByte() != 0;
|
||||
showProgressBar = in.readByte() != 0;
|
||||
autoZoomEnabled = in.readByte() != 0;
|
||||
multiTouchEnabled = in.readByte() != 0;
|
||||
maxZoom = in.readInt();
|
||||
initialCropWindowPaddingRatio = in.readFloat();
|
||||
fixAspectRatio = in.readByte() != 0;
|
||||
aspectRatioX = in.readInt();
|
||||
aspectRatioY = in.readInt();
|
||||
borderLineThickness = in.readFloat();
|
||||
borderLineColor = in.readInt();
|
||||
borderCornerThickness = in.readFloat();
|
||||
borderCornerOffset = in.readFloat();
|
||||
borderCornerLength = in.readFloat();
|
||||
borderCornerColor = in.readInt();
|
||||
guidelinesThickness = in.readFloat();
|
||||
guidelinesColor = in.readInt();
|
||||
backgroundColor = in.readInt();
|
||||
minCropWindowWidth = in.readInt();
|
||||
minCropWindowHeight = in.readInt();
|
||||
minCropResultWidth = in.readInt();
|
||||
minCropResultHeight = in.readInt();
|
||||
maxCropResultWidth = in.readInt();
|
||||
maxCropResultHeight = in.readInt();
|
||||
activityTitle = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
|
||||
activityMenuIconColor = in.readInt();
|
||||
outputUri = in.readParcelable(Uri.class.getClassLoader());
|
||||
outputCompressFormat = Bitmap.CompressFormat.valueOf(in.readString());
|
||||
outputCompressQuality = in.readInt();
|
||||
outputRequestWidth = in.readInt();
|
||||
outputRequestHeight = in.readInt();
|
||||
outputRequestSizeOptions = CropImageView.RequestSizeOptions.values()[in.readInt()];
|
||||
noOutputImage = in.readByte() != 0;
|
||||
initialCropWindowRectangle = in.readParcelable(Rect.class.getClassLoader());
|
||||
initialRotation = in.readInt();
|
||||
allowRotation = in.readByte() != 0;
|
||||
allowFlipping = in.readByte() != 0;
|
||||
allowCounterRotation = in.readByte() != 0;
|
||||
rotationDegrees = in.readInt();
|
||||
flipHorizontally = in.readByte() != 0;
|
||||
flipVertically = in.readByte() != 0;
|
||||
cropMenuCropButtonTitle = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
|
||||
cropMenuCropButtonIcon = in.readInt();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeToParcel(Parcel dest, int flags) {
|
||||
dest.writeInt(cropShape.ordinal());
|
||||
dest.writeFloat(snapRadius);
|
||||
dest.writeFloat(touchRadius);
|
||||
dest.writeInt(guidelines.ordinal());
|
||||
dest.writeInt(scaleType.ordinal());
|
||||
dest.writeByte((byte) (showCropOverlay ? 1 : 0));
|
||||
dest.writeByte((byte) (showProgressBar ? 1 : 0));
|
||||
dest.writeByte((byte) (autoZoomEnabled ? 1 : 0));
|
||||
dest.writeByte((byte) (multiTouchEnabled ? 1 : 0));
|
||||
dest.writeInt(maxZoom);
|
||||
dest.writeFloat(initialCropWindowPaddingRatio);
|
||||
dest.writeByte((byte) (fixAspectRatio ? 1 : 0));
|
||||
dest.writeInt(aspectRatioX);
|
||||
dest.writeInt(aspectRatioY);
|
||||
dest.writeFloat(borderLineThickness);
|
||||
dest.writeInt(borderLineColor);
|
||||
dest.writeFloat(borderCornerThickness);
|
||||
dest.writeFloat(borderCornerOffset);
|
||||
dest.writeFloat(borderCornerLength);
|
||||
dest.writeInt(borderCornerColor);
|
||||
dest.writeFloat(guidelinesThickness);
|
||||
dest.writeInt(guidelinesColor);
|
||||
dest.writeInt(backgroundColor);
|
||||
dest.writeInt(minCropWindowWidth);
|
||||
dest.writeInt(minCropWindowHeight);
|
||||
dest.writeInt(minCropResultWidth);
|
||||
dest.writeInt(minCropResultHeight);
|
||||
dest.writeInt(maxCropResultWidth);
|
||||
dest.writeInt(maxCropResultHeight);
|
||||
TextUtils.writeToParcel(activityTitle, dest, flags);
|
||||
dest.writeInt(activityMenuIconColor);
|
||||
dest.writeParcelable(outputUri, flags);
|
||||
dest.writeString(outputCompressFormat.name());
|
||||
dest.writeInt(outputCompressQuality);
|
||||
dest.writeInt(outputRequestWidth);
|
||||
dest.writeInt(outputRequestHeight);
|
||||
dest.writeInt(outputRequestSizeOptions.ordinal());
|
||||
dest.writeInt(noOutputImage ? 1 : 0);
|
||||
dest.writeParcelable(initialCropWindowRectangle, flags);
|
||||
dest.writeInt(initialRotation);
|
||||
dest.writeByte((byte) (allowRotation ? 1 : 0));
|
||||
dest.writeByte((byte) (allowFlipping ? 1 : 0));
|
||||
dest.writeByte((byte) (allowCounterRotation ? 1 : 0));
|
||||
dest.writeInt(rotationDegrees);
|
||||
dest.writeByte((byte) (flipHorizontally ? 1 : 0));
|
||||
dest.writeByte((byte) (flipVertically ? 1 : 0));
|
||||
TextUtils.writeToParcel(cropMenuCropButtonTitle, dest, flags);
|
||||
dest.writeInt(cropMenuCropButtonIcon);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int describeContents() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate all the options are withing valid range.
|
||||
*
|
||||
* @throws IllegalArgumentException if any of the options is not valid
|
||||
*/
|
||||
public void validate() {
|
||||
if (maxZoom < 0) {
|
||||
throw new IllegalArgumentException("Cannot set max zoom to a number < 1");
|
||||
}
|
||||
if (touchRadius < 0) {
|
||||
throw new IllegalArgumentException("Cannot set touch radius value to a number <= 0 ");
|
||||
}
|
||||
if (initialCropWindowPaddingRatio < 0 || initialCropWindowPaddingRatio >= 0.5) {
|
||||
throw new IllegalArgumentException(
|
||||
"Cannot set initial crop window padding value to a number < 0 or >= 0.5");
|
||||
}
|
||||
if (aspectRatioX <= 0) {
|
||||
throw new IllegalArgumentException(
|
||||
"Cannot set aspect ratio value to a number less than or equal to 0.");
|
||||
}
|
||||
if (aspectRatioY <= 0) {
|
||||
throw new IllegalArgumentException(
|
||||
"Cannot set aspect ratio value to a number less than or equal to 0.");
|
||||
}
|
||||
if (borderLineThickness < 0) {
|
||||
throw new IllegalArgumentException(
|
||||
"Cannot set line thickness value to a number less than 0.");
|
||||
}
|
||||
if (borderCornerThickness < 0) {
|
||||
throw new IllegalArgumentException(
|
||||
"Cannot set corner thickness value to a number less than 0.");
|
||||
}
|
||||
if (guidelinesThickness < 0) {
|
||||
throw new IllegalArgumentException(
|
||||
"Cannot set guidelines thickness value to a number less than 0.");
|
||||
}
|
||||
if (minCropWindowHeight < 0) {
|
||||
throw new IllegalArgumentException(
|
||||
"Cannot set min crop window height value to a number < 0 ");
|
||||
}
|
||||
if (minCropResultWidth < 0) {
|
||||
throw new IllegalArgumentException("Cannot set min crop result width value to a number < 0 ");
|
||||
}
|
||||
if (minCropResultHeight < 0) {
|
||||
throw new IllegalArgumentException(
|
||||
"Cannot set min crop result height value to a number < 0 ");
|
||||
}
|
||||
if (maxCropResultWidth < minCropResultWidth) {
|
||||
throw new IllegalArgumentException(
|
||||
"Cannot set max crop result width to smaller value than min crop result width");
|
||||
}
|
||||
if (maxCropResultHeight < minCropResultHeight) {
|
||||
throw new IllegalArgumentException(
|
||||
"Cannot set max crop result height to smaller value than min crop result height");
|
||||
}
|
||||
if (outputRequestWidth < 0) {
|
||||
throw new IllegalArgumentException("Cannot set request width value to a number < 0 ");
|
||||
}
|
||||
if (outputRequestHeight < 0) {
|
||||
throw new IllegalArgumentException("Cannot set request height value to a number < 0 ");
|
||||
}
|
||||
if (rotationDegrees < 0 || rotationDegrees > 360) {
|
||||
throw new IllegalArgumentException(
|
||||
"Cannot set rotation degrees value to a number < 0 or > 360");
|
||||
}
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,405 +0,0 @@
|
||||
// "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.theartofdev.edmodo.cropper;
|
||||
|
||||
import android.graphics.RectF;
|
||||
|
||||
/**
|
||||
* Handler from crop window stuff, moving and knowing possition.
|
||||
*/
|
||||
final class CropWindowHandler {
|
||||
|
||||
// region: Fields and Consts
|
||||
|
||||
/**
|
||||
* The 4 edges of the crop window defining its coordinates and size
|
||||
*/
|
||||
private final RectF mEdges = new RectF();
|
||||
|
||||
/**
|
||||
* Rectangle used to return the edges rectangle without ability to change it and without creating
|
||||
* new all the time.
|
||||
*/
|
||||
private final RectF mGetEdges = new RectF();
|
||||
|
||||
/**
|
||||
* Minimum width in pixels that the crop window can get.
|
||||
*/
|
||||
private float mMinCropWindowWidth;
|
||||
|
||||
/**
|
||||
* Minimum height in pixels that the crop window can get.
|
||||
*/
|
||||
private float mMinCropWindowHeight;
|
||||
|
||||
/**
|
||||
* Maximum width in pixels that the crop window can CURRENTLY get.
|
||||
*/
|
||||
private float mMaxCropWindowWidth;
|
||||
|
||||
/**
|
||||
* Maximum height in pixels that the crop window can CURRENTLY get.
|
||||
*/
|
||||
private float mMaxCropWindowHeight;
|
||||
|
||||
/**
|
||||
* Minimum width in pixels that the result of cropping an image can get, affects crop window width
|
||||
* adjusted by width scale factor.
|
||||
*/
|
||||
private float mMinCropResultWidth;
|
||||
|
||||
/**
|
||||
* Minimum height in pixels that the result of cropping an image can get, affects crop window
|
||||
* height adjusted by height scale factor.
|
||||
*/
|
||||
private float mMinCropResultHeight;
|
||||
|
||||
/**
|
||||
* Maximum width in pixels that the result of cropping an image can get, affects crop window width
|
||||
* adjusted by width scale factor.
|
||||
*/
|
||||
private float mMaxCropResultWidth;
|
||||
|
||||
/**
|
||||
* Maximum height in pixels that the result of cropping an image can get, affects crop window
|
||||
* height adjusted by height scale factor.
|
||||
*/
|
||||
private float mMaxCropResultHeight;
|
||||
|
||||
/**
|
||||
* The width scale factor of shown image and actual image
|
||||
*/
|
||||
private float mScaleFactorWidth = 1;
|
||||
|
||||
/**
|
||||
* The height scale factor of shown image and actual image
|
||||
*/
|
||||
private float mScaleFactorHeight = 1;
|
||||
// endregion
|
||||
|
||||
/**
|
||||
* Determines if the specified coordinate is in the target touch zone for a corner handle.
|
||||
*
|
||||
* @param x the x-coordinate of the touch point
|
||||
* @param y the y-coordinate of the touch point
|
||||
* @param handleX the x-coordinate of the corner handle
|
||||
* @param handleY the y-coordinate of the corner handle
|
||||
* @param targetRadius the target radius in pixels
|
||||
* @return true if the touch point is in the target touch zone; false otherwise
|
||||
*/
|
||||
private static boolean isInCornerTargetZone(
|
||||
float x, float y, float handleX, float handleY, float targetRadius) {
|
||||
return Math.abs(x - handleX) <= targetRadius && Math.abs(y - handleY) <= targetRadius;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the specified coordinate is in the target touch zone for a horizontal bar handle.
|
||||
*
|
||||
* @param x the x-coordinate of the touch point
|
||||
* @param y the y-coordinate of the touch point
|
||||
* @param handleXStart the left x-coordinate of the horizontal bar handle
|
||||
* @param handleXEnd the right x-coordinate of the horizontal bar handle
|
||||
* @param handleY the y-coordinate of the horizontal bar handle
|
||||
* @param targetRadius the target radius in pixels
|
||||
* @return true if the touch point is in the target touch zone; false otherwise
|
||||
*/
|
||||
private static boolean isInHorizontalTargetZone(
|
||||
float x, float y, float handleXStart, float handleXEnd, float handleY, float targetRadius) {
|
||||
return x > handleXStart && x < handleXEnd && Math.abs(y - handleY) <= targetRadius;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the specified coordinate is in the target touch zone for a vertical bar handle.
|
||||
*
|
||||
* @param x the x-coordinate of the touch point
|
||||
* @param y the y-coordinate of the touch point
|
||||
* @param handleX the x-coordinate of the vertical bar handle
|
||||
* @param handleYStart the top y-coordinate of the vertical bar handle
|
||||
* @param handleYEnd the bottom y-coordinate of the vertical bar handle
|
||||
* @param targetRadius the target radius in pixels
|
||||
* @return true if the touch point is in the target touch zone; false otherwise
|
||||
*/
|
||||
private static boolean isInVerticalTargetZone(
|
||||
float x, float y, float handleX, float handleYStart, float handleYEnd, float targetRadius) {
|
||||
return Math.abs(x - handleX) <= targetRadius && y > handleYStart && y < handleYEnd;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the specified coordinate falls anywhere inside the given bounds.
|
||||
*
|
||||
* @param x the x-coordinate of the touch point
|
||||
* @param y the y-coordinate of the touch point
|
||||
* @param left the x-coordinate of the left bound
|
||||
* @param top the y-coordinate of the top bound
|
||||
* @param right the x-coordinate of the right bound
|
||||
* @param bottom the y-coordinate of the bottom bound
|
||||
* @return true if the touch point is inside the bounding rectangle; false otherwise
|
||||
*/
|
||||
private static boolean isInCenterTargetZone(
|
||||
float x, float y, float left, float top, float right, float bottom) {
|
||||
return x > left && x < right && y > top && y < bottom;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the left/top/right/bottom coordinates of the crop window.
|
||||
*/
|
||||
public RectF getRect() {
|
||||
mGetEdges.set(mEdges);
|
||||
return mGetEdges;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the left/top/right/bottom coordinates of the crop window.
|
||||
*/
|
||||
public void setRect(RectF rect) {
|
||||
mEdges.set(rect);
|
||||
}
|
||||
|
||||
/**
|
||||
* Minimum width in pixels that the crop window can get.
|
||||
*/
|
||||
public float getMinCropWidth() {
|
||||
return Math.max(mMinCropWindowWidth, mMinCropResultWidth / mScaleFactorWidth);
|
||||
}
|
||||
|
||||
/**
|
||||
* Minimum height in pixels that the crop window can get.
|
||||
*/
|
||||
public float getMinCropHeight() {
|
||||
return Math.max(mMinCropWindowHeight, mMinCropResultHeight / mScaleFactorHeight);
|
||||
}
|
||||
|
||||
/**
|
||||
* Maximum width in pixels that the crop window can get.
|
||||
*/
|
||||
public float getMaxCropWidth() {
|
||||
return Math.min(mMaxCropWindowWidth, mMaxCropResultWidth / mScaleFactorWidth);
|
||||
}
|
||||
|
||||
/**
|
||||
* Maximum height in pixels that the crop window can get.
|
||||
*/
|
||||
public float getMaxCropHeight() {
|
||||
return Math.min(mMaxCropWindowHeight, mMaxCropResultHeight / mScaleFactorHeight);
|
||||
}
|
||||
|
||||
/**
|
||||
* get the scale factor (on width) of the showen image to original image.
|
||||
*/
|
||||
public float getScaleFactorWidth() {
|
||||
return mScaleFactorWidth;
|
||||
}
|
||||
|
||||
/**
|
||||
* get the scale factor (on height) of the showen image to original image.
|
||||
*/
|
||||
public float getScaleFactorHeight() {
|
||||
return mScaleFactorHeight;
|
||||
}
|
||||
|
||||
/**
|
||||
* the min size the resulting cropping image is allowed to be, affects the cropping window limits
|
||||
* (in pixels).<br>
|
||||
*/
|
||||
public void setMinCropResultSize(int minCropResultWidth, int minCropResultHeight) {
|
||||
mMinCropResultWidth = minCropResultWidth;
|
||||
mMinCropResultHeight = minCropResultHeight;
|
||||
}
|
||||
|
||||
/**
|
||||
* the max size the resulting cropping image is allowed to be, affects the cropping window limits
|
||||
* (in pixels).<br>
|
||||
*/
|
||||
public void setMaxCropResultSize(int maxCropResultWidth, int maxCropResultHeight) {
|
||||
mMaxCropResultWidth = maxCropResultWidth;
|
||||
mMaxCropResultHeight = maxCropResultHeight;
|
||||
}
|
||||
|
||||
// region: Private methods
|
||||
|
||||
/**
|
||||
* set the max width/height and scale factor of the showen image to original image to scale the
|
||||
* limits appropriately.
|
||||
*/
|
||||
public void setCropWindowLimits(
|
||||
float maxWidth, float maxHeight, float scaleFactorWidth, float scaleFactorHeight) {
|
||||
mMaxCropWindowWidth = maxWidth;
|
||||
mMaxCropWindowHeight = maxHeight;
|
||||
mScaleFactorWidth = scaleFactorWidth;
|
||||
mScaleFactorHeight = scaleFactorHeight;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the variables to be used during crop window handling.
|
||||
*/
|
||||
public void setInitialAttributeValues(CropImageOptions options) {
|
||||
mMinCropWindowWidth = options.minCropWindowWidth;
|
||||
mMinCropWindowHeight = options.minCropWindowHeight;
|
||||
mMinCropResultWidth = options.minCropResultWidth;
|
||||
mMinCropResultHeight = options.minCropResultHeight;
|
||||
mMaxCropResultWidth = options.maxCropResultWidth;
|
||||
mMaxCropResultHeight = options.maxCropResultHeight;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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 boolean showGuidelines() {
|
||||
return !(mEdges.width() < 100 || mEdges.height() < 100);
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines which, if any, of the handles are pressed given the touch coordinates, the bounding
|
||||
* box, and the touch radius.
|
||||
*
|
||||
* @param x the x-coordinate of the touch point
|
||||
* @param y the y-coordinate of the touch point
|
||||
* @param targetRadius the target radius in pixels
|
||||
* @return the Handle that was pressed; null if no Handle was pressed
|
||||
*/
|
||||
public CropWindowMoveHandler getMoveHandler(
|
||||
float x, float y, float targetRadius, CropImageView.CropShape cropShape) {
|
||||
CropWindowMoveHandler.Type type =
|
||||
cropShape == CropImageView.CropShape.OVAL
|
||||
? getOvalPressedMoveType(x, y)
|
||||
: getRectanglePressedMoveType(x, y, targetRadius);
|
||||
return type != null ? new CropWindowMoveHandler(type, this, x, y) : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines which, if any, of the handles are pressed given the touch coordinates, the bounding
|
||||
* box, and the touch radius.
|
||||
*
|
||||
* @param x the x-coordinate of the touch point
|
||||
* @param y the y-coordinate of the touch point
|
||||
* @param targetRadius the target radius in pixels
|
||||
* @return the Handle that was pressed; null if no Handle was pressed
|
||||
*/
|
||||
private CropWindowMoveHandler.Type getRectanglePressedMoveType(
|
||||
float x, float y, float targetRadius) {
|
||||
CropWindowMoveHandler.Type moveType = null;
|
||||
|
||||
// Note: corner-handles take precedence, then side-handles, then center.
|
||||
if (CropWindowHandler.isInCornerTargetZone(x, y, mEdges.left, mEdges.top, targetRadius)) {
|
||||
moveType = CropWindowMoveHandler.Type.TOP_LEFT;
|
||||
} else if (CropWindowHandler.isInCornerTargetZone(
|
||||
x, y, mEdges.right, mEdges.top, targetRadius)) {
|
||||
moveType = CropWindowMoveHandler.Type.TOP_RIGHT;
|
||||
} else if (CropWindowHandler.isInCornerTargetZone(
|
||||
x, y, mEdges.left, mEdges.bottom, targetRadius)) {
|
||||
moveType = CropWindowMoveHandler.Type.BOTTOM_LEFT;
|
||||
} else if (CropWindowHandler.isInCornerTargetZone(
|
||||
x, y, mEdges.right, mEdges.bottom, targetRadius)) {
|
||||
moveType = CropWindowMoveHandler.Type.BOTTOM_RIGHT;
|
||||
} else if (CropWindowHandler.isInCenterTargetZone(
|
||||
x, y, mEdges.left, mEdges.top, mEdges.right, mEdges.bottom)
|
||||
&& focusCenter()) {
|
||||
moveType = CropWindowMoveHandler.Type.CENTER;
|
||||
} else if (CropWindowHandler.isInHorizontalTargetZone(
|
||||
x, y, mEdges.left, mEdges.right, mEdges.top, targetRadius)) {
|
||||
moveType = CropWindowMoveHandler.Type.TOP;
|
||||
} else if (CropWindowHandler.isInHorizontalTargetZone(
|
||||
x, y, mEdges.left, mEdges.right, mEdges.bottom, targetRadius)) {
|
||||
moveType = CropWindowMoveHandler.Type.BOTTOM;
|
||||
} else if (CropWindowHandler.isInVerticalTargetZone(
|
||||
x, y, mEdges.left, mEdges.top, mEdges.bottom, targetRadius)) {
|
||||
moveType = CropWindowMoveHandler.Type.LEFT;
|
||||
} else if (CropWindowHandler.isInVerticalTargetZone(
|
||||
x, y, mEdges.right, mEdges.top, mEdges.bottom, targetRadius)) {
|
||||
moveType = CropWindowMoveHandler.Type.RIGHT;
|
||||
} else if (CropWindowHandler.isInCenterTargetZone(
|
||||
x, y, mEdges.left, mEdges.top, mEdges.right, mEdges.bottom)
|
||||
&& !focusCenter()) {
|
||||
moveType = CropWindowMoveHandler.Type.CENTER;
|
||||
}
|
||||
|
||||
return moveType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines which, if any, of the handles are pressed given the touch coordinates, the bounding
|
||||
* box/oval, and the touch radius.
|
||||
*
|
||||
* @param x the x-coordinate of the touch point
|
||||
* @param y the y-coordinate of the touch point
|
||||
* @return the Handle that was pressed; null if no Handle was pressed
|
||||
*/
|
||||
private CropWindowMoveHandler.Type getOvalPressedMoveType(float x, float y) {
|
||||
|
||||
/*
|
||||
Use a 6x6 grid system divided into 9 "handles", with the center the biggest region. While
|
||||
this is not perfect, it's a good quick-to-ship approach.
|
||||
|
||||
TL T T T T TR
|
||||
L C C C C R
|
||||
L C C C C R
|
||||
L C C C C R
|
||||
L C C C C R
|
||||
BL B B B B BR
|
||||
*/
|
||||
|
||||
float cellLength = mEdges.width() / 6;
|
||||
float leftCenter = mEdges.left + cellLength;
|
||||
float rightCenter = mEdges.left + (5 * cellLength);
|
||||
|
||||
float cellHeight = mEdges.height() / 6;
|
||||
float topCenter = mEdges.top + cellHeight;
|
||||
float bottomCenter = mEdges.top + 5 * cellHeight;
|
||||
|
||||
CropWindowMoveHandler.Type moveType;
|
||||
if (x < leftCenter) {
|
||||
if (y < topCenter) {
|
||||
moveType = CropWindowMoveHandler.Type.TOP_LEFT;
|
||||
} else if (y < bottomCenter) {
|
||||
moveType = CropWindowMoveHandler.Type.LEFT;
|
||||
} else {
|
||||
moveType = CropWindowMoveHandler.Type.BOTTOM_LEFT;
|
||||
}
|
||||
} else if (x < rightCenter) {
|
||||
if (y < topCenter) {
|
||||
moveType = CropWindowMoveHandler.Type.TOP;
|
||||
} else if (y < bottomCenter) {
|
||||
moveType = CropWindowMoveHandler.Type.CENTER;
|
||||
} else {
|
||||
moveType = CropWindowMoveHandler.Type.BOTTOM;
|
||||
}
|
||||
} else {
|
||||
if (y < topCenter) {
|
||||
moveType = CropWindowMoveHandler.Type.TOP_RIGHT;
|
||||
} else if (y < bottomCenter) {
|
||||
moveType = CropWindowMoveHandler.Type.RIGHT;
|
||||
} else {
|
||||
moveType = CropWindowMoveHandler.Type.BOTTOM_RIGHT;
|
||||
}
|
||||
}
|
||||
|
||||
return moveType;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the cropper should focus on the center handle or the side handles. If it is a
|
||||
* small image, focus on the center handle so the user can move it. If it is a large image, focus
|
||||
* on the side handles so user can grab them. Corresponds to the appearance of the
|
||||
* RuleOfThirdsGuidelines.
|
||||
*
|
||||
* @return true if it is small enough such that it should focus on the center; less than
|
||||
* show_guidelines limit
|
||||
*/
|
||||
private boolean focusCenter() {
|
||||
return !showGuidelines();
|
||||
}
|
||||
// endregion
|
||||
}
|
||||
@ -1,786 +0,0 @@
|
||||
// "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.theartofdev.edmodo.cropper;
|
||||
|
||||
import android.graphics.Matrix;
|
||||
import android.graphics.PointF;
|
||||
import android.graphics.RectF;
|
||||
|
||||
/**
|
||||
* Handler to update crop window edges by the move type - Horizontal, Vertical, Corner or Center.
|
||||
* <br>
|
||||
*/
|
||||
final class CropWindowMoveHandler {
|
||||
|
||||
// region: Fields and Consts
|
||||
|
||||
/**
|
||||
* Matrix used for rectangle rotation handling
|
||||
*/
|
||||
private static final Matrix MATRIX = new Matrix();
|
||||
|
||||
/**
|
||||
* Minimum width in pixels that the crop window can get.
|
||||
*/
|
||||
private final float mMinCropWidth;
|
||||
|
||||
/**
|
||||
* Minimum width in pixels that the crop window can get.
|
||||
*/
|
||||
private final float mMinCropHeight;
|
||||
|
||||
/**
|
||||
* Maximum height in pixels that the crop window can get.
|
||||
*/
|
||||
private final float mMaxCropWidth;
|
||||
|
||||
/**
|
||||
* Maximum height in pixels that the crop window can get.
|
||||
*/
|
||||
private final float mMaxCropHeight;
|
||||
|
||||
/**
|
||||
* The type of crop window move that is handled.
|
||||
*/
|
||||
private final Type mType;
|
||||
|
||||
/**
|
||||
* 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 final PointF mTouchOffset = new PointF();
|
||||
// endregion
|
||||
|
||||
/**
|
||||
* @param edgeMoveType the type of move this handler is executing
|
||||
* @param horizontalEdge the primary edge associated with this handle; may be null
|
||||
* @param verticalEdge the secondary edge associated with this handle; may be null
|
||||
* @param cropWindowHandler main crop window handle to get and update the crop window edges
|
||||
* @param touchX the location of the initial toch possition to measure move distance
|
||||
* @param touchY the location of the initial toch possition to measure move distance
|
||||
*/
|
||||
public CropWindowMoveHandler(
|
||||
Type type, CropWindowHandler cropWindowHandler, float touchX, float touchY) {
|
||||
mType = type;
|
||||
mMinCropWidth = cropWindowHandler.getMinCropWidth();
|
||||
mMinCropHeight = cropWindowHandler.getMinCropHeight();
|
||||
mMaxCropWidth = cropWindowHandler.getMaxCropWidth();
|
||||
mMaxCropHeight = cropWindowHandler.getMaxCropHeight();
|
||||
calculateTouchOffset(cropWindowHandler.getRect(), touchX, touchY);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the aspect ratio given a rectangle.
|
||||
*/
|
||||
private static float calculateAspectRatio(float left, float top, float right, float bottom) {
|
||||
return (right - left) / (bottom - top);
|
||||
}
|
||||
|
||||
// region: Private methods
|
||||
|
||||
/**
|
||||
* Updates the crop window by change in the toch location.<br>
|
||||
* Move type handled by this instance, as initialized in creation, affects how the change in toch
|
||||
* location changes the crop window position and size.<br>
|
||||
* After the crop window position/size is changed by toch move it may result in values that
|
||||
* vialate contraints: outside the bounds of the shown bitmap, smaller/larger than min/max size or
|
||||
* missmatch in aspect ratio. So a series of fixes is executed on "secondary" edges to adjust it
|
||||
* by the "primary" edge movement.<br>
|
||||
* Primary is the edge directly affected by move type, secondary is the other edge.<br>
|
||||
* The crop window is changed by directly setting the Edge coordinates.
|
||||
*
|
||||
* @param x the new x-coordinate of this handle
|
||||
* @param y the new y-coordinate of this handle
|
||||
* @param bounds the bounding rectangle of the image
|
||||
* @param viewWidth The bounding image view width used to know the crop overlay is at view edges.
|
||||
* @param viewHeight The bounding image view height used to know the crop overlay is at view
|
||||
* edges.
|
||||
* @param parentView the parent View containing the image
|
||||
* @param snapMargin the maximum distance (in pixels) at which the crop window should snap to the
|
||||
* image
|
||||
* @param fixedAspectRatio is the aspect ration fixed and 'targetAspectRatio' should be used
|
||||
* @param aspectRatio the aspect ratio to maintain
|
||||
*/
|
||||
public void move(
|
||||
RectF rect,
|
||||
float x,
|
||||
float y,
|
||||
RectF bounds,
|
||||
int viewWidth,
|
||||
int viewHeight,
|
||||
float snapMargin,
|
||||
boolean fixedAspectRatio,
|
||||
float aspectRatio) {
|
||||
|
||||
// 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".
|
||||
float adjX = x + mTouchOffset.x;
|
||||
float adjY = y + mTouchOffset.y;
|
||||
|
||||
if (mType == Type.CENTER) {
|
||||
moveCenter(rect, adjX, adjY, bounds, viewWidth, viewHeight, snapMargin);
|
||||
} else {
|
||||
if (fixedAspectRatio) {
|
||||
moveSizeWithFixedAspectRatio(
|
||||
rect, adjX, adjY, bounds, viewWidth, viewHeight, snapMargin, aspectRatio);
|
||||
} else {
|
||||
moveSizeWithFreeAspectRatio(rect, adjX, adjY, bounds, viewWidth, viewHeight, snapMargin);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the offset of the touch point from the precise location of the specified handle.<br>
|
||||
* Save these values in a member variable since we want to maintain this offset as we drag the
|
||||
* handle.
|
||||
*/
|
||||
private void calculateTouchOffset(RectF rect, float touchX, float touchY) {
|
||||
|
||||
float touchOffsetX = 0;
|
||||
float touchOffsetY = 0;
|
||||
|
||||
// Calculate the offset from the appropriate handle.
|
||||
switch (mType) {
|
||||
case TOP_LEFT:
|
||||
touchOffsetX = rect.left - touchX;
|
||||
touchOffsetY = rect.top - touchY;
|
||||
break;
|
||||
case TOP_RIGHT:
|
||||
touchOffsetX = rect.right - touchX;
|
||||
touchOffsetY = rect.top - touchY;
|
||||
break;
|
||||
case BOTTOM_LEFT:
|
||||
touchOffsetX = rect.left - touchX;
|
||||
touchOffsetY = rect.bottom - touchY;
|
||||
break;
|
||||
case BOTTOM_RIGHT:
|
||||
touchOffsetX = rect.right - touchX;
|
||||
touchOffsetY = rect.bottom - touchY;
|
||||
break;
|
||||
case LEFT:
|
||||
touchOffsetX = rect.left - touchX;
|
||||
touchOffsetY = 0;
|
||||
break;
|
||||
case TOP:
|
||||
touchOffsetX = 0;
|
||||
touchOffsetY = rect.top - touchY;
|
||||
break;
|
||||
case RIGHT:
|
||||
touchOffsetX = rect.right - touchX;
|
||||
touchOffsetY = 0;
|
||||
break;
|
||||
case BOTTOM:
|
||||
touchOffsetX = 0;
|
||||
touchOffsetY = rect.bottom - touchY;
|
||||
break;
|
||||
case CENTER:
|
||||
touchOffsetX = rect.centerX() - touchX;
|
||||
touchOffsetY = rect.centerY() - touchY;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
mTouchOffset.x = touchOffsetX;
|
||||
mTouchOffset.y = touchOffsetY;
|
||||
}
|
||||
|
||||
/**
|
||||
* Center move only changes the position of the crop window without changing the size.
|
||||
*/
|
||||
private void moveCenter(
|
||||
RectF rect, float x, float y, RectF bounds, int viewWidth, int viewHeight, float snapRadius) {
|
||||
float dx = x - rect.centerX();
|
||||
float dy = y - rect.centerY();
|
||||
if (rect.left + dx < 0
|
||||
|| rect.right + dx > viewWidth
|
||||
|| rect.left + dx < bounds.left
|
||||
|| rect.right + dx > bounds.right) {
|
||||
dx /= 1.05f;
|
||||
mTouchOffset.x -= dx / 2;
|
||||
}
|
||||
if (rect.top + dy < 0
|
||||
|| rect.bottom + dy > viewHeight
|
||||
|| rect.top + dy < bounds.top
|
||||
|| rect.bottom + dy > bounds.bottom) {
|
||||
dy /= 1.05f;
|
||||
mTouchOffset.y -= dy / 2;
|
||||
}
|
||||
rect.offset(dx, dy);
|
||||
snapEdgesToBounds(rect, bounds, snapRadius);
|
||||
}
|
||||
|
||||
/**
|
||||
* Change the size of the crop window on the required edge (or edges for corner size move) without
|
||||
* affecting "secondary" edges.<br>
|
||||
* Only the primary edge(s) are fixed to stay within limits.
|
||||
*/
|
||||
private void moveSizeWithFreeAspectRatio(
|
||||
RectF rect, float x, float y, RectF bounds, int viewWidth, int viewHeight, float snapMargin) {
|
||||
switch (mType) {
|
||||
case TOP_LEFT:
|
||||
adjustTop(rect, y, bounds, snapMargin, 0, false, false);
|
||||
adjustLeft(rect, x, bounds, snapMargin, 0, false, false);
|
||||
break;
|
||||
case TOP_RIGHT:
|
||||
adjustTop(rect, y, bounds, snapMargin, 0, false, false);
|
||||
adjustRight(rect, x, bounds, viewWidth, snapMargin, 0, false, false);
|
||||
break;
|
||||
case BOTTOM_LEFT:
|
||||
adjustBottom(rect, y, bounds, viewHeight, snapMargin, 0, false, false);
|
||||
adjustLeft(rect, x, bounds, snapMargin, 0, false, false);
|
||||
break;
|
||||
case BOTTOM_RIGHT:
|
||||
adjustBottom(rect, y, bounds, viewHeight, snapMargin, 0, false, false);
|
||||
adjustRight(rect, x, bounds, viewWidth, snapMargin, 0, false, false);
|
||||
break;
|
||||
case LEFT:
|
||||
adjustLeft(rect, x, bounds, snapMargin, 0, false, false);
|
||||
break;
|
||||
case TOP:
|
||||
adjustTop(rect, y, bounds, snapMargin, 0, false, false);
|
||||
break;
|
||||
case RIGHT:
|
||||
adjustRight(rect, x, bounds, viewWidth, snapMargin, 0, false, false);
|
||||
break;
|
||||
case BOTTOM:
|
||||
adjustBottom(rect, y, bounds, viewHeight, snapMargin, 0, false, false);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Change the size of the crop window on the required "primary" edge WITH affect to relevant
|
||||
* "secondary" edge via aspect ratio.<br>
|
||||
* Example: change in the left edge (primary) will affect top and bottom edges (secondary) to
|
||||
* preserve the given aspect ratio.
|
||||
*/
|
||||
private void moveSizeWithFixedAspectRatio(
|
||||
RectF rect,
|
||||
float x,
|
||||
float y,
|
||||
RectF bounds,
|
||||
int viewWidth,
|
||||
int viewHeight,
|
||||
float snapMargin,
|
||||
float aspectRatio) {
|
||||
switch (mType) {
|
||||
case TOP_LEFT:
|
||||
if (calculateAspectRatio(x, y, rect.right, rect.bottom) < aspectRatio) {
|
||||
adjustTop(rect, y, bounds, snapMargin, aspectRatio, true, false);
|
||||
adjustLeftByAspectRatio(rect, aspectRatio);
|
||||
} else {
|
||||
adjustLeft(rect, x, bounds, snapMargin, aspectRatio, true, false);
|
||||
adjustTopByAspectRatio(rect, aspectRatio);
|
||||
}
|
||||
break;
|
||||
case TOP_RIGHT:
|
||||
if (calculateAspectRatio(rect.left, y, x, rect.bottom) < aspectRatio) {
|
||||
adjustTop(rect, y, bounds, snapMargin, aspectRatio, false, true);
|
||||
adjustRightByAspectRatio(rect, aspectRatio);
|
||||
} else {
|
||||
adjustRight(rect, x, bounds, viewWidth, snapMargin, aspectRatio, true, false);
|
||||
adjustTopByAspectRatio(rect, aspectRatio);
|
||||
}
|
||||
break;
|
||||
case BOTTOM_LEFT:
|
||||
if (calculateAspectRatio(x, rect.top, rect.right, y) < aspectRatio) {
|
||||
adjustBottom(rect, y, bounds, viewHeight, snapMargin, aspectRatio, true, false);
|
||||
adjustLeftByAspectRatio(rect, aspectRatio);
|
||||
} else {
|
||||
adjustLeft(rect, x, bounds, snapMargin, aspectRatio, false, true);
|
||||
adjustBottomByAspectRatio(rect, aspectRatio);
|
||||
}
|
||||
break;
|
||||
case BOTTOM_RIGHT:
|
||||
if (calculateAspectRatio(rect.left, rect.top, x, y) < aspectRatio) {
|
||||
adjustBottom(rect, y, bounds, viewHeight, snapMargin, aspectRatio, false, true);
|
||||
adjustRightByAspectRatio(rect, aspectRatio);
|
||||
} else {
|
||||
adjustRight(rect, x, bounds, viewWidth, snapMargin, aspectRatio, false, true);
|
||||
adjustBottomByAspectRatio(rect, aspectRatio);
|
||||
}
|
||||
break;
|
||||
case LEFT:
|
||||
adjustLeft(rect, x, bounds, snapMargin, aspectRatio, true, true);
|
||||
adjustTopBottomByAspectRatio(rect, bounds, aspectRatio);
|
||||
break;
|
||||
case TOP:
|
||||
adjustTop(rect, y, bounds, snapMargin, aspectRatio, true, true);
|
||||
adjustLeftRightByAspectRatio(rect, bounds, aspectRatio);
|
||||
break;
|
||||
case RIGHT:
|
||||
adjustRight(rect, x, bounds, viewWidth, snapMargin, aspectRatio, true, true);
|
||||
adjustTopBottomByAspectRatio(rect, bounds, aspectRatio);
|
||||
break;
|
||||
case BOTTOM:
|
||||
adjustBottom(rect, y, bounds, viewHeight, snapMargin, aspectRatio, true, true);
|
||||
adjustLeftRightByAspectRatio(rect, bounds, aspectRatio);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if edges have gone out of bounds (including snap margin), and fix if needed.
|
||||
*/
|
||||
private void snapEdgesToBounds(RectF edges, RectF bounds, float margin) {
|
||||
if (edges.left < bounds.left + margin) {
|
||||
edges.offset(bounds.left - edges.left, 0);
|
||||
}
|
||||
if (edges.top < bounds.top + margin) {
|
||||
edges.offset(0, bounds.top - edges.top);
|
||||
}
|
||||
if (edges.right > bounds.right - margin) {
|
||||
edges.offset(bounds.right - edges.right, 0);
|
||||
}
|
||||
if (edges.bottom > bounds.bottom - margin) {
|
||||
edges.offset(0, bounds.bottom - edges.bottom);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the resulting x-position of the left edge of the crop window given the handle's position
|
||||
* and the image's bounding box and snap radius.
|
||||
*
|
||||
* @param left the position that the left edge is dragged to
|
||||
* @param bounds the bounding box of the image that is being cropped
|
||||
* @param snapMargin the snap distance to the image edge (in pixels)
|
||||
*/
|
||||
private void adjustLeft(
|
||||
RectF rect,
|
||||
float left,
|
||||
RectF bounds,
|
||||
float snapMargin,
|
||||
float aspectRatio,
|
||||
boolean topMoves,
|
||||
boolean bottomMoves) {
|
||||
|
||||
float newLeft = left;
|
||||
|
||||
if (newLeft < 0) {
|
||||
newLeft /= 1.05f;
|
||||
mTouchOffset.x -= newLeft / 1.1f;
|
||||
}
|
||||
|
||||
if (newLeft < bounds.left) {
|
||||
mTouchOffset.x -= (newLeft - bounds.left) / 2f;
|
||||
}
|
||||
|
||||
if (newLeft - bounds.left < snapMargin) {
|
||||
newLeft = bounds.left;
|
||||
}
|
||||
|
||||
// Checks if the window is too small horizontally
|
||||
if (rect.right - newLeft < mMinCropWidth) {
|
||||
newLeft = rect.right - mMinCropWidth;
|
||||
}
|
||||
|
||||
// Checks if the window is too large horizontally
|
||||
if (rect.right - newLeft > mMaxCropWidth) {
|
||||
newLeft = rect.right - mMaxCropWidth;
|
||||
}
|
||||
|
||||
if (newLeft - bounds.left < snapMargin) {
|
||||
newLeft = bounds.left;
|
||||
}
|
||||
|
||||
// check vertical bounds if aspect ratio is in play
|
||||
if (aspectRatio > 0) {
|
||||
float newHeight = (rect.right - newLeft) / aspectRatio;
|
||||
|
||||
// Checks if the window is too small vertically
|
||||
if (newHeight < mMinCropHeight) {
|
||||
newLeft = Math.max(bounds.left, rect.right - mMinCropHeight * aspectRatio);
|
||||
newHeight = (rect.right - newLeft) / aspectRatio;
|
||||
}
|
||||
|
||||
// Checks if the window is too large vertically
|
||||
if (newHeight > mMaxCropHeight) {
|
||||
newLeft = Math.max(bounds.left, rect.right - mMaxCropHeight * aspectRatio);
|
||||
newHeight = (rect.right - newLeft) / aspectRatio;
|
||||
}
|
||||
|
||||
// if top AND bottom edge moves by aspect ratio check that it is within full height bounds
|
||||
if (topMoves && bottomMoves) {
|
||||
newLeft =
|
||||
Math.max(newLeft, Math.max(bounds.left, rect.right - bounds.height() * aspectRatio));
|
||||
} else {
|
||||
// if top edge moves by aspect ratio check that it is within bounds
|
||||
if (topMoves && rect.bottom - newHeight < bounds.top) {
|
||||
newLeft = Math.max(bounds.left, rect.right - (rect.bottom - bounds.top) * aspectRatio);
|
||||
newHeight = (rect.right - newLeft) / aspectRatio;
|
||||
}
|
||||
|
||||
// if bottom edge moves by aspect ratio check that it is within bounds
|
||||
if (bottomMoves && rect.top + newHeight > bounds.bottom) {
|
||||
newLeft =
|
||||
Math.max(
|
||||
newLeft,
|
||||
Math.max(bounds.left, rect.right - (bounds.bottom - rect.top) * aspectRatio));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
rect.left = newLeft;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the resulting x-position of the right edge of the crop window given the handle's position
|
||||
* and the image's bounding box and snap radius.
|
||||
*
|
||||
* @param right the position that the right edge is dragged to
|
||||
* @param bounds the bounding box of the image that is being cropped
|
||||
* @param viewWidth
|
||||
* @param snapMargin the snap distance to the image edge (in pixels)
|
||||
*/
|
||||
private void adjustRight(
|
||||
RectF rect,
|
||||
float right,
|
||||
RectF bounds,
|
||||
int viewWidth,
|
||||
float snapMargin,
|
||||
float aspectRatio,
|
||||
boolean topMoves,
|
||||
boolean bottomMoves) {
|
||||
|
||||
float newRight = right;
|
||||
|
||||
if (newRight > viewWidth) {
|
||||
newRight = viewWidth + (newRight - viewWidth) / 1.05f;
|
||||
mTouchOffset.x -= (newRight - viewWidth) / 1.1f;
|
||||
}
|
||||
|
||||
if (newRight > bounds.right) {
|
||||
mTouchOffset.x -= (newRight - bounds.right) / 2f;
|
||||
}
|
||||
|
||||
// If close to the edge
|
||||
if (bounds.right - newRight < snapMargin) {
|
||||
newRight = bounds.right;
|
||||
}
|
||||
|
||||
// Checks if the window is too small horizontally
|
||||
if (newRight - rect.left < mMinCropWidth) {
|
||||
newRight = rect.left + mMinCropWidth;
|
||||
}
|
||||
|
||||
// Checks if the window is too large horizontally
|
||||
if (newRight - rect.left > mMaxCropWidth) {
|
||||
newRight = rect.left + mMaxCropWidth;
|
||||
}
|
||||
|
||||
// If close to the edge
|
||||
if (bounds.right - newRight < snapMargin) {
|
||||
newRight = bounds.right;
|
||||
}
|
||||
|
||||
// check vertical bounds if aspect ratio is in play
|
||||
if (aspectRatio > 0) {
|
||||
float newHeight = (newRight - rect.left) / aspectRatio;
|
||||
|
||||
// Checks if the window is too small vertically
|
||||
if (newHeight < mMinCropHeight) {
|
||||
newRight = Math.min(bounds.right, rect.left + mMinCropHeight * aspectRatio);
|
||||
newHeight = (newRight - rect.left) / aspectRatio;
|
||||
}
|
||||
|
||||
// Checks if the window is too large vertically
|
||||
if (newHeight > mMaxCropHeight) {
|
||||
newRight = Math.min(bounds.right, rect.left + mMaxCropHeight * aspectRatio);
|
||||
newHeight = (newRight - rect.left) / aspectRatio;
|
||||
}
|
||||
|
||||
// if top AND bottom edge moves by aspect ratio check that it is within full height bounds
|
||||
if (topMoves && bottomMoves) {
|
||||
newRight =
|
||||
Math.min(newRight, Math.min(bounds.right, rect.left + bounds.height() * aspectRatio));
|
||||
} else {
|
||||
// if top edge moves by aspect ratio check that it is within bounds
|
||||
if (topMoves && rect.bottom - newHeight < bounds.top) {
|
||||
newRight = Math.min(bounds.right, rect.left + (rect.bottom - bounds.top) * aspectRatio);
|
||||
newHeight = (newRight - rect.left) / aspectRatio;
|
||||
}
|
||||
|
||||
// if bottom edge moves by aspect ratio check that it is within bounds
|
||||
if (bottomMoves && rect.top + newHeight > bounds.bottom) {
|
||||
newRight =
|
||||
Math.min(
|
||||
newRight,
|
||||
Math.min(bounds.right, rect.left + (bounds.bottom - rect.top) * aspectRatio));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
rect.right = newRight;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the resulting y-position of the top edge of the crop window given the handle's position and
|
||||
* the image's bounding box and snap radius.
|
||||
*
|
||||
* @param top the x-position that the top edge is dragged to
|
||||
* @param bounds the bounding box of the image that is being cropped
|
||||
* @param snapMargin the snap distance to the image edge (in pixels)
|
||||
*/
|
||||
private void adjustTop(
|
||||
RectF rect,
|
||||
float top,
|
||||
RectF bounds,
|
||||
float snapMargin,
|
||||
float aspectRatio,
|
||||
boolean leftMoves,
|
||||
boolean rightMoves) {
|
||||
|
||||
float newTop = top;
|
||||
|
||||
if (newTop < 0) {
|
||||
newTop /= 1.05f;
|
||||
mTouchOffset.y -= newTop / 1.1f;
|
||||
}
|
||||
|
||||
if (newTop < bounds.top) {
|
||||
mTouchOffset.y -= (newTop - bounds.top) / 2f;
|
||||
}
|
||||
|
||||
if (newTop - bounds.top < snapMargin) {
|
||||
newTop = bounds.top;
|
||||
}
|
||||
|
||||
// Checks if the window is too small vertically
|
||||
if (rect.bottom - newTop < mMinCropHeight) {
|
||||
newTop = rect.bottom - mMinCropHeight;
|
||||
}
|
||||
|
||||
// Checks if the window is too large vertically
|
||||
if (rect.bottom - newTop > mMaxCropHeight) {
|
||||
newTop = rect.bottom - mMaxCropHeight;
|
||||
}
|
||||
|
||||
if (newTop - bounds.top < snapMargin) {
|
||||
newTop = bounds.top;
|
||||
}
|
||||
|
||||
// check horizontal bounds if aspect ratio is in play
|
||||
if (aspectRatio > 0) {
|
||||
float newWidth = (rect.bottom - newTop) * aspectRatio;
|
||||
|
||||
// Checks if the crop window is too small horizontally due to aspect ratio adjustment
|
||||
if (newWidth < mMinCropWidth) {
|
||||
newTop = Math.max(bounds.top, rect.bottom - (mMinCropWidth / aspectRatio));
|
||||
newWidth = (rect.bottom - newTop) * aspectRatio;
|
||||
}
|
||||
|
||||
// Checks if the crop window is too large horizontally due to aspect ratio adjustment
|
||||
if (newWidth > mMaxCropWidth) {
|
||||
newTop = Math.max(bounds.top, rect.bottom - (mMaxCropWidth / aspectRatio));
|
||||
newWidth = (rect.bottom - newTop) * aspectRatio;
|
||||
}
|
||||
|
||||
// if left AND right edge moves by aspect ratio check that it is within full width bounds
|
||||
if (leftMoves && rightMoves) {
|
||||
newTop = Math.max(newTop, Math.max(bounds.top, rect.bottom - bounds.width() / aspectRatio));
|
||||
} else {
|
||||
// if left edge moves by aspect ratio check that it is within bounds
|
||||
if (leftMoves && rect.right - newWidth < bounds.left) {
|
||||
newTop = Math.max(bounds.top, rect.bottom - (rect.right - bounds.left) / aspectRatio);
|
||||
newWidth = (rect.bottom - newTop) * aspectRatio;
|
||||
}
|
||||
|
||||
// if right edge moves by aspect ratio check that it is within bounds
|
||||
if (rightMoves && rect.left + newWidth > bounds.right) {
|
||||
newTop =
|
||||
Math.max(
|
||||
newTop,
|
||||
Math.max(bounds.top, rect.bottom - (bounds.right - rect.left) / aspectRatio));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
rect.top = newTop;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the resulting y-position of the bottom edge of the crop window given the handle's position
|
||||
* and the image's bounding box and snap radius.
|
||||
*
|
||||
* @param bottom the position that the bottom edge is dragged to
|
||||
* @param bounds the bounding box of the image that is being cropped
|
||||
* @param viewHeight
|
||||
* @param snapMargin the snap distance to the image edge (in pixels)
|
||||
*/
|
||||
private void adjustBottom(
|
||||
RectF rect,
|
||||
float bottom,
|
||||
RectF bounds,
|
||||
int viewHeight,
|
||||
float snapMargin,
|
||||
float aspectRatio,
|
||||
boolean leftMoves,
|
||||
boolean rightMoves) {
|
||||
|
||||
float newBottom = bottom;
|
||||
|
||||
if (newBottom > viewHeight) {
|
||||
newBottom = viewHeight + (newBottom - viewHeight) / 1.05f;
|
||||
mTouchOffset.y -= (newBottom - viewHeight) / 1.1f;
|
||||
}
|
||||
|
||||
if (newBottom > bounds.bottom) {
|
||||
mTouchOffset.y -= (newBottom - bounds.bottom) / 2f;
|
||||
}
|
||||
|
||||
if (bounds.bottom - newBottom < snapMargin) {
|
||||
newBottom = bounds.bottom;
|
||||
}
|
||||
|
||||
// Checks if the window is too small vertically
|
||||
if (newBottom - rect.top < mMinCropHeight) {
|
||||
newBottom = rect.top + mMinCropHeight;
|
||||
}
|
||||
|
||||
// Checks if the window is too small vertically
|
||||
if (newBottom - rect.top > mMaxCropHeight) {
|
||||
newBottom = rect.top + mMaxCropHeight;
|
||||
}
|
||||
|
||||
if (bounds.bottom - newBottom < snapMargin) {
|
||||
newBottom = bounds.bottom;
|
||||
}
|
||||
|
||||
// check horizontal bounds if aspect ratio is in play
|
||||
if (aspectRatio > 0) {
|
||||
float newWidth = (newBottom - rect.top) * aspectRatio;
|
||||
|
||||
// Checks if the window is too small horizontally
|
||||
if (newWidth < mMinCropWidth) {
|
||||
newBottom = Math.min(bounds.bottom, rect.top + mMinCropWidth / aspectRatio);
|
||||
newWidth = (newBottom - rect.top) * aspectRatio;
|
||||
}
|
||||
|
||||
// Checks if the window is too large horizontally
|
||||
if (newWidth > mMaxCropWidth) {
|
||||
newBottom = Math.min(bounds.bottom, rect.top + mMaxCropWidth / aspectRatio);
|
||||
newWidth = (newBottom - rect.top) * aspectRatio;
|
||||
}
|
||||
|
||||
// if left AND right edge moves by aspect ratio check that it is within full width bounds
|
||||
if (leftMoves && rightMoves) {
|
||||
newBottom =
|
||||
Math.min(newBottom, Math.min(bounds.bottom, rect.top + bounds.width() / aspectRatio));
|
||||
} else {
|
||||
// if left edge moves by aspect ratio check that it is within bounds
|
||||
if (leftMoves && rect.right - newWidth < bounds.left) {
|
||||
newBottom = Math.min(bounds.bottom, rect.top + (rect.right - bounds.left) / aspectRatio);
|
||||
newWidth = (newBottom - rect.top) * aspectRatio;
|
||||
}
|
||||
|
||||
// if right edge moves by aspect ratio check that it is within bounds
|
||||
if (rightMoves && rect.left + newWidth > bounds.right) {
|
||||
newBottom =
|
||||
Math.min(
|
||||
newBottom,
|
||||
Math.min(bounds.bottom, rect.top + (bounds.right - rect.left) / aspectRatio));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
rect.bottom = newBottom;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adjust left edge by current crop window height and the given aspect ratio, the right edge
|
||||
* remains in possition while the left adjusts to keep aspect ratio to the height.
|
||||
*/
|
||||
private void adjustLeftByAspectRatio(RectF rect, float aspectRatio) {
|
||||
rect.left = rect.right - rect.height() * aspectRatio;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adjust top edge by current crop window width and the given aspect ratio, the bottom edge
|
||||
* remains in possition while the top adjusts to keep aspect ratio to the width.
|
||||
*/
|
||||
private void adjustTopByAspectRatio(RectF rect, float aspectRatio) {
|
||||
rect.top = rect.bottom - rect.width() / aspectRatio;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adjust right edge by current crop window height and the given aspect ratio, the left edge
|
||||
* remains in possition while the left adjusts to keep aspect ratio to the height.
|
||||
*/
|
||||
private void adjustRightByAspectRatio(RectF rect, float aspectRatio) {
|
||||
rect.right = rect.left + rect.height() * aspectRatio;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adjust bottom edge by current crop window width and the given aspect ratio, the top edge
|
||||
* remains in possition while the top adjusts to keep aspect ratio to the width.
|
||||
*/
|
||||
private void adjustBottomByAspectRatio(RectF rect, float aspectRatio) {
|
||||
rect.bottom = rect.top + rect.width() / aspectRatio;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adjust left and right edges by current crop window height and the given aspect ratio, both
|
||||
* right and left edges adjusts equally relative to center to keep aspect ratio to the height.
|
||||
*/
|
||||
private void adjustLeftRightByAspectRatio(RectF rect, RectF bounds, float aspectRatio) {
|
||||
rect.inset((rect.width() - rect.height() * aspectRatio) / 2, 0);
|
||||
if (rect.left < bounds.left) {
|
||||
rect.offset(bounds.left - rect.left, 0);
|
||||
}
|
||||
if (rect.right > bounds.right) {
|
||||
rect.offset(bounds.right - rect.right, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Adjust top and bottom edges by current crop window width and the given aspect ratio, both top
|
||||
* and bottom edges adjusts equally relative to center to keep aspect ratio to the width.
|
||||
*/
|
||||
private void adjustTopBottomByAspectRatio(RectF rect, RectF bounds, float aspectRatio) {
|
||||
rect.inset(0, (rect.height() - rect.width() / aspectRatio) / 2);
|
||||
if (rect.top < bounds.top) {
|
||||
rect.offset(0, bounds.top - rect.top);
|
||||
}
|
||||
if (rect.bottom > bounds.bottom) {
|
||||
rect.offset(0, bounds.bottom - rect.bottom);
|
||||
}
|
||||
}
|
||||
// endregion
|
||||
|
||||
// region: Inner class: Type
|
||||
|
||||
/**
|
||||
* The type of crop window move that is handled.
|
||||
*/
|
||||
public enum Type {
|
||||
TOP_LEFT,
|
||||
TOP_RIGHT,
|
||||
BOTTOM_LEFT,
|
||||
BOTTOM_RIGHT,
|
||||
LEFT,
|
||||
TOP,
|
||||
RIGHT,
|
||||
BOTTOM,
|
||||
CENTER
|
||||
}
|
||||
// endregion
|
||||
}
|
||||
|
Before Width: | Height: | Size: 262 B |
|
Before Width: | Height: | Size: 634 B |
|
Before Width: | Height: | Size: 617 B |
|
Before Width: | Height: | Size: 259 B |
|
Before Width: | Height: | Size: 798 B |
|
Before Width: | Height: | Size: 787 B |
|
Before Width: | Height: | Size: 417 B |
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue