Durban config.
24 | * Created by Yan Zhenjie on 2017/5/30. 25 | */ 26 | public class DurbanConfig { 27 | 28 | /** 29 | * Create a new builder. 30 | */ 31 | public static Builder newBuilder(Context context) { 32 | return new Builder(context); 33 | } 34 | 35 | private Locale mLocale; 36 | 37 | private DurbanConfig(Builder build) { 38 | this.mLocale = build.mLocale; 39 | } 40 | 41 | /** 42 | * Get {@link Locale}. 43 | * 44 | * @return {@link Locale}. 45 | */ 46 | public Locale getLocale() { 47 | return mLocale; 48 | } 49 | 50 | public static final class Builder { 51 | 52 | private Locale mLocale; 53 | 54 | private Builder(Context context) { 55 | } 56 | 57 | /** 58 | * Set locale for language. 59 | * 60 | * @param locale {@link Locale}. 61 | * @return {@link Builder}. 62 | */ 63 | public Builder setLocale(Locale locale) { 64 | this.mLocale = locale; 65 | return this; 66 | } 67 | 68 | /** 69 | * Create AlbumConfig. 70 | * 71 | * @return {@link DurbanConfig}. 72 | */ 73 | public DurbanConfig build() { 74 | return new DurbanConfig(this); 75 | } 76 | } 77 | 78 | } 79 | -------------------------------------------------------------------------------- /durban/src/main/java/com/yanzhenjie/durban/model/CropParameters.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © Yan Zhenjie 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | package com.yanzhenjie.durban.model; 17 | 18 | import android.graphics.Bitmap; 19 | 20 | /** 21 | * Update by Yan Zhenjie on 2017/5/23. 22 | */ 23 | public class CropParameters { 24 | 25 | private int mMaxResultImageSizeX, mMaxResultImageSizeY; 26 | 27 | private Bitmap.CompressFormat mCompressFormat; 28 | private int mCompressQuality; 29 | private String mImagePath; 30 | private String mImageOutputPath; 31 | private ExifInfo mExifInfo; 32 | 33 | 34 | public CropParameters( 35 | int maxResultImageSizeX, 36 | int maxResultImageSizeY, 37 | Bitmap.CompressFormat compressFormat, 38 | int compressQuality, 39 | String imagePath, 40 | String imageOutputPath, 41 | ExifInfo exifInfo) { 42 | mMaxResultImageSizeX = maxResultImageSizeX; 43 | mMaxResultImageSizeY = maxResultImageSizeY; 44 | mCompressFormat = compressFormat; 45 | mCompressQuality = compressQuality; 46 | this.mImagePath = imagePath; 47 | mImageOutputPath = imageOutputPath; 48 | mExifInfo = exifInfo; 49 | } 50 | 51 | public int getMaxResultImageSizeX() { 52 | return mMaxResultImageSizeX; 53 | } 54 | 55 | public int getMaxResultImageSizeY() { 56 | return mMaxResultImageSizeY; 57 | } 58 | 59 | public Bitmap.CompressFormat getCompressFormat() { 60 | return mCompressFormat; 61 | } 62 | 63 | public int getCompressQuality() { 64 | return mCompressQuality; 65 | } 66 | 67 | public String getImagePath() { 68 | return mImagePath; 69 | } 70 | 71 | public String getImageOutputPath() { 72 | return mImageOutputPath; 73 | } 74 | 75 | public ExifInfo getExifInfo() { 76 | return mExifInfo; 77 | } 78 | 79 | } 80 | -------------------------------------------------------------------------------- /durban/src/main/java/com/yanzhenjie/durban/model/ExifInfo.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © Yan Zhenjie 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | package com.yanzhenjie.durban.model; 17 | 18 | /** 19 | * Update by Yan Zhenjie on 2017/5/23. 20 | */ 21 | public class ExifInfo { 22 | 23 | private int mExifOrientation; 24 | private int mExifDegrees; 25 | private int mExifTranslation; 26 | 27 | public ExifInfo(int exifOrientation, int exifDegrees, int exifTranslation) { 28 | mExifOrientation = exifOrientation; 29 | mExifDegrees = exifDegrees; 30 | mExifTranslation = exifTranslation; 31 | } 32 | 33 | public int getExifOrientation() { 34 | return mExifOrientation; 35 | } 36 | 37 | public int getExifDegrees() { 38 | return mExifDegrees; 39 | } 40 | 41 | public int getExifTranslation() { 42 | return mExifTranslation; 43 | } 44 | 45 | public void setExifOrientation(int exifOrientation) { 46 | mExifOrientation = exifOrientation; 47 | } 48 | 49 | public void setExifDegrees(int exifDegrees) { 50 | mExifDegrees = exifDegrees; 51 | } 52 | 53 | public void setExifTranslation(int exifTranslation) { 54 | mExifTranslation = exifTranslation; 55 | } 56 | 57 | @Override 58 | public boolean equals(Object o) { 59 | if (this == o) return true; 60 | if (o == null || getClass() != o.getClass()) return false; 61 | 62 | ExifInfo exifInfo = (ExifInfo) o; 63 | 64 | if (mExifOrientation != exifInfo.mExifOrientation) return false; 65 | if (mExifDegrees != exifInfo.mExifDegrees) return false; 66 | return mExifTranslation == exifInfo.mExifTranslation; 67 | 68 | } 69 | 70 | @Override 71 | public int hashCode() { 72 | int result = mExifOrientation; 73 | result = 31 * result + mExifDegrees; 74 | result = 31 * result + mExifTranslation; 75 | return result; 76 | } 77 | 78 | } 79 | -------------------------------------------------------------------------------- /durban/src/main/java/com/yanzhenjie/durban/model/AspectRatio.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © Yan Zhenjie 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | package com.yanzhenjie.durban.model; 17 | 18 | import android.os.Parcel; 19 | import android.os.Parcelable; 20 | import android.support.annotation.Nullable; 21 | 22 | /** 23 | * Update by Yan Zhenjie on 2017/5/23. 24 | */ 25 | public class AspectRatio implements Parcelable { 26 | 27 | @Nullable 28 | private final String mAspectRatioTitle; 29 | private final float mAspectRatioX; 30 | private final float mAspectRatioY; 31 | 32 | public AspectRatio(@Nullable String aspectRatioTitle, float aspectRatioX, float aspectRatioY) { 33 | mAspectRatioTitle = aspectRatioTitle; 34 | mAspectRatioX = aspectRatioX; 35 | mAspectRatioY = aspectRatioY; 36 | } 37 | 38 | protected AspectRatio(Parcel in) { 39 | mAspectRatioTitle = in.readString(); 40 | mAspectRatioX = in.readFloat(); 41 | mAspectRatioY = in.readFloat(); 42 | } 43 | 44 | @Override 45 | public void writeToParcel(Parcel dest, int flags) { 46 | dest.writeString(mAspectRatioTitle); 47 | dest.writeFloat(mAspectRatioX); 48 | dest.writeFloat(mAspectRatioY); 49 | } 50 | 51 | @Override 52 | public int describeContents() { 53 | return 0; 54 | } 55 | 56 | public static final CreatorImage adapter.
31 | * Created by Yan Zhenjie on 2016/10/30. 32 | */ 33 | public class GridAdapter extends RecyclerView.AdapterControl panel configuration.
23 | * Created by Yan Zhenjie on 2017/5/30. 24 | */ 25 | public class Controller implements Parcelable { 26 | 27 | private Controller(Parcel in) { 28 | this.enable = in.readByte() != 0; 29 | this.rotation = in.readByte() != 0; 30 | this.rotationTitle = in.readByte() != 0; 31 | this.scale = in.readByte() != 0; 32 | this.scaleTitle = in.readByte() != 0; 33 | } 34 | 35 | @Override 36 | public void writeToParcel(Parcel dest, int flags) { 37 | dest.writeByte((byte) (enable ? 1 : 0)); 38 | dest.writeByte((byte) (rotation ? 1 : 0)); 39 | dest.writeByte((byte) (rotationTitle ? 1 : 0)); 40 | dest.writeByte((byte) (scale ? 1 : 0)); 41 | dest.writeByte((byte) (scaleTitle ? 1 : 0)); 42 | } 43 | 44 | @Override 45 | public int describeContents() { 46 | return 0; 47 | } 48 | 49 | public static final Creator32 | * Asynchronous loading of images. 33 | *
34 | * Create by Yan Zhenjie on 2017/5/22. 35 | */ 36 | public class BitmapLoadTask extends AsyncTaskCut and save the image asynchronously.
41 | * Create by Yan Zhenjie on 2017/5/22. 42 | */ 43 | public class BitmapCropTask extends AsyncTaskEntrance.
38 | * Create by Yan Zhenjie on 2017/5/23. 39 | */ 40 | public class Durban { 41 | 42 | private static final String KEY_PREFIX = "AlbumCrop"; 43 | 44 | static final String KEY_INPUT_STATUS_COLOR = KEY_PREFIX + ".KEY_INPUT_STATUS_COLOR"; 45 | static final String KEY_INPUT_TOOLBAR_COLOR = KEY_PREFIX + ".KEY_INPUT_TOOLBAR_COLOR"; 46 | static final String KEY_INPUT_NAVIGATION_COLOR = KEY_PREFIX + ".KEY_INPUT_NAVIGATION_COLOR"; 47 | static final String KEY_INPUT_TITLE = KEY_PREFIX + ".KEY_INPUT_TITLE"; 48 | 49 | static final String KEY_INPUT_GESTURE = KEY_PREFIX + ".KEY_INPUT_GESTURE"; 50 | static final String KEY_INPUT_ASPECT_RATIO = KEY_PREFIX + ".KEY_INPUT_ASPECT_RATIO"; 51 | static final String KEY_INPUT_MAX_WIDTH_HEIGHT = KEY_PREFIX + ".KEY_INPUT_MAX_WIDTH_HEIGHT"; 52 | 53 | static final String KEY_INPUT_COMPRESS_FORMAT = KEY_PREFIX + ".KEY_INPUT_COMPRESS_FORMAT"; 54 | static final String KEY_INPUT_COMPRESS_QUALITY = KEY_PREFIX + ".KEY_INPUT_COMPRESS_QUALITY"; 55 | 56 | static final String KEY_INPUT_DIRECTORY = KEY_PREFIX + ".KEY_INPUT_DIRECTORY"; 57 | static final String KEY_INPUT_PATH_ARRAY = KEY_PREFIX + ".KEY_INPUT_PATH_ARRAY"; 58 | 59 | static final String KEY_INPUT_CONTROLLER = KEY_PREFIX + ".KEY_INPUT_CONTROLLER"; 60 | 61 | static final String KEY_OUTPUT_IMAGE_LIST = KEY_PREFIX + ".KEY_OUTPUT_IMAGE_LIST"; 62 | 63 | /** 64 | * Do not allow any gestures. 65 | */ 66 | public static final int GESTURE_NONE = 0; 67 | /** 68 | * Allow scaling. 69 | */ 70 | public static final int GESTURE_SCALE = 1; 71 | /** 72 | * Allow rotation. 73 | */ 74 | public static final int GESTURE_ROTATE = 2; 75 | /** 76 | * Allow rotation and scaling. 77 | */ 78 | public static final int GESTURE_ALL = 3; 79 | 80 | @IntDef({GESTURE_NONE, GESTURE_SCALE, GESTURE_ROTATE, GESTURE_ALL}) 81 | @Retention(RetentionPolicy.SOURCE) 82 | public @interface GestureTypes { 83 | } 84 | 85 | /** 86 | * JPEG format. 87 | */ 88 | public static final int COMPRESS_JPEG = 0; 89 | /** 90 | * PNG format. 91 | */ 92 | public static final int COMPRESS_PNG = 1; 93 | 94 | @IntDef({COMPRESS_JPEG, COMPRESS_PNG}) 95 | @Retention(RetentionPolicy.SOURCE) 96 | public @interface FormatTypes { 97 | } 98 | 99 | private static DurbanConfig sDurbanConfig; 100 | 101 | /** 102 | * Initialize Album. 103 | * 104 | * @param durbanConfig {@link DurbanConfig}. 105 | */ 106 | public static void initialize(DurbanConfig durbanConfig) { 107 | sDurbanConfig = durbanConfig; 108 | } 109 | 110 | /** 111 | * Get the durban configuration. 112 | * 113 | * @return {@link DurbanConfig}. 114 | */ 115 | public static DurbanConfig getDurbanConfig() { 116 | if (sDurbanConfig == null) { 117 | initialize(DurbanConfig.newBuilder(null) 118 | .setLocale(Locale.getDefault()) 119 | .build() 120 | ); 121 | } 122 | return sDurbanConfig; 123 | } 124 | 125 | 126 | private Object o; 127 | private Intent mCropIntent; 128 | 129 | public static Durban with(Activity activity) { 130 | return new Durban(activity); 131 | } 132 | 133 | public static Durban with(Fragment fragment) { 134 | return new Durban(fragment); 135 | } 136 | 137 | public static Durban with(android.app.Fragment fragment) { 138 | return new Durban(fragment); 139 | } 140 | 141 | private Durban(Object o) { 142 | this.o = o; 143 | mCropIntent = new Intent(getContext(o), DurbanActivity.class); 144 | } 145 | 146 | /** 147 | * The color of the StatusBar. 148 | */ 149 | public Durban statusBarColor(@ColorInt int color) { 150 | mCropIntent.putExtra(KEY_INPUT_STATUS_COLOR, color); 151 | return this; 152 | } 153 | 154 | /** 155 | * The color of the Toolbar. 156 | */ 157 | public Durban toolBarColor(@ColorInt int color) { 158 | mCropIntent.putExtra(KEY_INPUT_TOOLBAR_COLOR, color); 159 | return this; 160 | } 161 | 162 | /** 163 | * Set the color of the NavigationBar. 164 | */ 165 | public Durban navigationBarColor(@ColorInt int color) { 166 | mCropIntent.putExtra(KEY_INPUT_NAVIGATION_COLOR, color); 167 | return this; 168 | } 169 | 170 | /** 171 | * The title of the interface. 172 | */ 173 | public Durban title(String title) { 174 | mCropIntent.putExtra(KEY_INPUT_TITLE, title); 175 | return this; 176 | } 177 | 178 | /** 179 | * The gestures that allow operation. 180 | * 181 | * @param gesture gesture sign. 182 | * @see #GESTURE_NONE 183 | * @see #GESTURE_ALL 184 | * @see #GESTURE_ROTATE 185 | * @see #GESTURE_SCALE 186 | */ 187 | public Durban gesture(@GestureTypes int gesture) { 188 | mCropIntent.putExtra(KEY_INPUT_GESTURE, gesture); 189 | return this; 190 | } 191 | 192 | /** 193 | * The aspect ratio column of the crop box. 194 | * 195 | * @param x aspect ratio X. 196 | * @param y aspect ratio Y. 197 | */ 198 | public Durban aspectRatio(float x, float y) { 199 | mCropIntent.putExtra(KEY_INPUT_ASPECT_RATIO, new float[]{x, y}); 200 | return this; 201 | } 202 | 203 | /** 204 | * Use the aspect ratio column of the original image. 205 | */ 206 | public Durban aspectRatioWithSourceImage() { 207 | return aspectRatio(0F, 0F); 208 | } 209 | 210 | /** 211 | * Set maximum size for result cropped image. 212 | * 213 | * @param width max cropped image width. 214 | * @param height max cropped image height. 215 | */ 216 | public Durban maxWidthHeight(@IntRange(from = 100) int width, @IntRange(from = 100) int height) { 217 | mCropIntent.putExtra(KEY_INPUT_MAX_WIDTH_HEIGHT, new int[]{width, height}); 218 | return this; 219 | } 220 | 221 | /** 222 | * The compression format of the cropped image. 223 | * 224 | * @param format image format. 225 | * @see #COMPRESS_JPEG 226 | * @see #COMPRESS_PNG 227 | */ 228 | public Durban compressFormat(@FormatTypes int format) { 229 | mCropIntent.putExtra(KEY_INPUT_COMPRESS_FORMAT, format); 230 | return this; 231 | } 232 | 233 | /** 234 | * The compression quality of the cropped image. 235 | * 236 | * @param quality see {@link Bitmap#compress(Bitmap.CompressFormat, int, OutputStream)}. 237 | * @see Bitmap#compress(Bitmap.CompressFormat, int, OutputStream) 238 | */ 239 | public Durban compressQuality(int quality) { 240 | mCropIntent.putExtra(KEY_INPUT_COMPRESS_QUALITY, quality); 241 | return this; 242 | } 243 | 244 | /** 245 | * Set the output directory of the cropped picture. 246 | */ 247 | public Durban outputDirectory(String folder) { 248 | mCropIntent.putExtra(KEY_INPUT_DIRECTORY, folder); 249 | return this; 250 | } 251 | 252 | /** 253 | * The pictures to be cropped. 254 | */ 255 | public Durban inputImagePaths(String... imagePathArray) { 256 | ArrayList39 | * This class provides base logic to setup the image, transform it with matrix (move, scale, rotate), 40 | * and methods to get current matrix state. 41 | *
42 | * Update by Yan Zhenjie on 2017/5/23. 43 | */ 44 | public class TransformImageView extends android.support.v7.widget.AppCompatImageView { 45 | 46 | private static final String TAG = "TransformImageView"; 47 | 48 | private static final int RECT_CORNER_POINTS_COORDS = 8; 49 | private static final int RECT_CENTER_POINT_COORDS = 2; 50 | private static final int MATRIX_VALUES_COUNT = 9; 51 | 52 | protected final float[] mCurrentImageCorners = new float[RECT_CORNER_POINTS_COORDS]; 53 | protected final float[] mCurrentImageCenter = new float[RECT_CENTER_POINT_COORDS]; 54 | 55 | private final float[] mMatrixValues = new float[MATRIX_VALUES_COUNT]; 56 | 57 | protected Matrix mCurrentImageMatrix = new Matrix(); 58 | protected int mThisWidth, mThisHeight; 59 | 60 | protected TransformImageListener mTransformImageListener; 61 | 62 | private float[] mInitialImageCorners; 63 | private float[] mInitialImageCenter; 64 | 65 | protected boolean mBitmapDecoded = false; 66 | protected boolean mBitmapLaidOut = false; 67 | 68 | private int mMaxBitmapSize = 0; 69 | 70 | private String mImagePath, mOutputDirectory; 71 | private ExifInfo mExifInfo; 72 | 73 | /** 74 | * Interface for rotation and scale change notifying. 75 | */ 76 | public interface TransformImageListener { 77 | 78 | void onLoadComplete(); 79 | 80 | void onLoadFailure(); 81 | 82 | void onRotate(float currentAngle); 83 | 84 | void onScale(float currentScale); 85 | } 86 | 87 | public TransformImageView(Context context) { 88 | this(context, null); 89 | } 90 | 91 | public TransformImageView(Context context, AttributeSet attrs) { 92 | this(context, attrs, 0); 93 | } 94 | 95 | public TransformImageView(Context context, AttributeSet attrs, int defStyle) { 96 | super(context, attrs, defStyle); 97 | init(); 98 | } 99 | 100 | public void setTransformImageListener(TransformImageListener transformImageListener) { 101 | mTransformImageListener = transformImageListener; 102 | } 103 | 104 | @Override 105 | public void setScaleType(ScaleType scaleType) { 106 | if (scaleType == ScaleType.MATRIX) { 107 | super.setScaleType(scaleType); 108 | } else { 109 | Log.w(TAG, "Invalid ScaleType. Only ScaleType.MATRIX can be used"); 110 | } 111 | } 112 | 113 | /** 114 | * Setter for {@link #mMaxBitmapSize} value. 115 | * Be sure to call it before {@link #setImageURI(Uri)} or other image setters. 116 | * 117 | * @param maxBitmapSize - max size for both width and height of exception that will be used in the view. 118 | */ 119 | public void setMaxBitmapSize(int maxBitmapSize) { 120 | mMaxBitmapSize = maxBitmapSize; 121 | } 122 | 123 | public int getMaxBitmapSize() { 124 | if (mMaxBitmapSize <= 0) { 125 | mMaxBitmapSize = BitmapLoadUtils.calculateMaxBitmapSize(getContext()); 126 | } 127 | return mMaxBitmapSize; 128 | } 129 | 130 | @Override 131 | public void setImageBitmap(final Bitmap bitmap) { 132 | setImageDrawable(new FastBitmapDrawable(bitmap)); 133 | } 134 | 135 | public String getImagePath() { 136 | return mImagePath; 137 | } 138 | 139 | public String getOutputDirectory() { 140 | return mOutputDirectory; 141 | } 142 | 143 | public ExifInfo getExifInfo() { 144 | return mExifInfo; 145 | } 146 | 147 | public void setOutputDirectory(String outputDirectory) { 148 | this.mOutputDirectory = outputDirectory; 149 | } 150 | 151 | /** 152 | * This method takes an Uri as a parameter, then calls method to decode it into Bitmap with specified size. 153 | * 154 | * @param inputImagePath - image Uri 155 | * @throws Exception - can throw exception if having problems with decoding Uri or OOM. 156 | */ 157 | public void setImagePath(@NonNull String inputImagePath) throws Exception { 158 | this.mImagePath = inputImagePath; 159 | int maxBitmapSize = getMaxBitmapSize(); 160 | 161 | new BitmapLoadTask( 162 | getContext(), 163 | maxBitmapSize, 164 | maxBitmapSize, 165 | new BitmapLoadCallback() { 166 | @Override 167 | public void onSuccessfully(@NonNull Bitmap bitmap, @NonNull ExifInfo exifInfo) { 168 | mExifInfo = exifInfo; 169 | mBitmapDecoded = true; 170 | setImageBitmap(bitmap); 171 | } 172 | 173 | @Override 174 | public void onFailure() { 175 | if (mTransformImageListener != null) { 176 | mTransformImageListener.onLoadFailure(); 177 | } 178 | } 179 | } 180 | ).execute(inputImagePath); 181 | } 182 | 183 | /** 184 | * @return - current image scale value. 185 | * [1.0f - for original image, 2.0f - for 200% scaled image, etc.] 186 | */ 187 | public float getCurrentScale() { 188 | return getMatrixScale(mCurrentImageMatrix); 189 | } 190 | 191 | /** 192 | * This method calculates scale value for given Matrix object. 193 | */ 194 | public float getMatrixScale(@NonNull Matrix matrix) { 195 | return (float) Math.sqrt(Math.pow(getMatrixValue(matrix, Matrix.MSCALE_X), 2) 196 | + Math.pow(getMatrixValue(matrix, Matrix.MSKEW_Y), 2)); 197 | } 198 | 199 | /** 200 | * @return - current image rotation angle. 201 | */ 202 | public float getCurrentAngle() { 203 | return getMatrixAngle(mCurrentImageMatrix); 204 | } 205 | 206 | /** 207 | * This method calculates rotation angle for given Matrix object. 208 | */ 209 | public float getMatrixAngle(@NonNull Matrix matrix) { 210 | return (float) -(Math.atan2(getMatrixValue(matrix, Matrix.MSKEW_X), 211 | getMatrixValue(matrix, Matrix.MSCALE_X)) * (180 / Math.PI)); 212 | } 213 | 214 | @Override 215 | public void setImageMatrix(Matrix matrix) { 216 | super.setImageMatrix(matrix); 217 | mCurrentImageMatrix.set(matrix); 218 | updateCurrentImagePoints(); 219 | } 220 | 221 | @Nullable 222 | public Bitmap getViewBitmap() { 223 | if (getDrawable() == null || !(getDrawable() instanceof FastBitmapDrawable)) return null; 224 | else return ((FastBitmapDrawable) getDrawable()).getBitmap(); 225 | } 226 | 227 | /** 228 | * This method translates current image. 229 | * 230 | * @param deltaX - horizontal shift 231 | * @param deltaY - vertical shift 232 | */ 233 | public void postTranslate(float deltaX, float deltaY) { 234 | if (deltaX != 0 || deltaY != 0) { 235 | mCurrentImageMatrix.postTranslate(deltaX, deltaY); 236 | setImageMatrix(mCurrentImageMatrix); 237 | } 238 | } 239 | 240 | /** 241 | * This method scales current image. 242 | * 243 | * @param deltaScale - scale value 244 | * @param px - scale center X 245 | * @param py - scale center Y 246 | */ 247 | public void postScale(float deltaScale, float px, float py) { 248 | if (deltaScale != 0) { 249 | mCurrentImageMatrix.postScale(deltaScale, deltaScale, px, py); 250 | setImageMatrix(mCurrentImageMatrix); 251 | if (mTransformImageListener != null) { 252 | mTransformImageListener.onScale(getMatrixScale(mCurrentImageMatrix)); 253 | } 254 | } 255 | } 256 | 257 | /** 258 | * This method rotates current image. 259 | * 260 | * @param deltaAngle - rotation angle 261 | * @param px - rotation center X 262 | * @param py - rotation center Y 263 | */ 264 | public void postRotate(float deltaAngle, float px, float py) { 265 | if (deltaAngle != 0) { 266 | mCurrentImageMatrix.postRotate(deltaAngle, px, py); 267 | setImageMatrix(mCurrentImageMatrix); 268 | if (mTransformImageListener != null) { 269 | mTransformImageListener.onRotate(getMatrixAngle(mCurrentImageMatrix)); 270 | } 271 | } 272 | } 273 | 274 | protected void init() { 275 | setScaleType(ScaleType.MATRIX); 276 | } 277 | 278 | @Override 279 | protected void onLayout(boolean changed, int left, int top, int right, int bottom) { 280 | super.onLayout(changed, left, top, right, bottom); 281 | if (changed || (mBitmapDecoded && !mBitmapLaidOut)) { 282 | 283 | left = getPaddingLeft(); 284 | top = getPaddingTop(); 285 | right = getWidth() - getPaddingRight(); 286 | bottom = getHeight() - getPaddingBottom(); 287 | mThisWidth = right - left; 288 | mThisHeight = bottom - top; 289 | 290 | onImageLaidOut(); 291 | } 292 | } 293 | 294 | /** 295 | * When image is laid out {@link #mInitialImageCenter} and {@link #mInitialImageCenter} 296 | * must be set. 297 | */ 298 | protected void onImageLaidOut() { 299 | final Drawable drawable = getDrawable(); 300 | if (drawable == null) { 301 | return; 302 | } 303 | 304 | float w = drawable.getIntrinsicWidth(); 305 | float h = drawable.getIntrinsicHeight(); 306 | 307 | Log.d(TAG, String.format("Image size: [%d:%d]", (int) w, (int) h)); 308 | 309 | RectF initialImageRect = new RectF(0, 0, w, h); 310 | mInitialImageCorners = RectUtils.getCornersFromRect(initialImageRect); 311 | mInitialImageCenter = RectUtils.getCenterFromRect(initialImageRect); 312 | 313 | mBitmapLaidOut = true; 314 | 315 | if (mTransformImageListener != null) { 316 | mTransformImageListener.onLoadComplete(); 317 | } 318 | } 319 | 320 | /** 321 | * This method returns Matrix value for given index. 322 | * 323 | * @param matrix - valid Matrix object 324 | * @param valueIndex - index of needed value. See {@link Matrix#MSCALE_X} and others. 325 | * @return - matrix value for index 326 | */ 327 | protected float getMatrixValue(@NonNull Matrix matrix, @IntRange(from = 0, to = MATRIX_VALUES_COUNT) int valueIndex) { 328 | matrix.getValues(mMatrixValues); 329 | return mMatrixValues[valueIndex]; 330 | } 331 | 332 | /** 333 | * This method logs given matrix X, Y, scale, and angle values. 334 | * Can be used for debug. 335 | */ 336 | @SuppressWarnings("unused") 337 | protected void printMatrix(@NonNull String logPrefix, @NonNull Matrix matrix) { 338 | float x = getMatrixValue(matrix, Matrix.MTRANS_X); 339 | float y = getMatrixValue(matrix, Matrix.MTRANS_Y); 340 | float rScale = getMatrixScale(matrix); 341 | float rAngle = getMatrixAngle(matrix); 342 | Log.d(TAG, logPrefix + ": matrix: { x: " + x + ", y: " + y + ", scale: " + rScale + ", angle: " + rAngle + " }"); 343 | } 344 | 345 | /** 346 | * This method updates current image corners and center points that are stored in 347 | * {@link #mCurrentImageCorners} and {@link #mCurrentImageCenter} arrays. 348 | * Those are used for several calculations. 349 | */ 350 | private void updateCurrentImagePoints() { 351 | mCurrentImageMatrix.mapPoints(mCurrentImageCorners, mInitialImageCorners); 352 | mCurrentImageMatrix.mapPoints(mCurrentImageCenter, mInitialImageCenter); 353 | } 354 | 355 | } 356 | -------------------------------------------------------------------------------- /durban/src/main/java/com/yanzhenjie/durban/util/ImageHeaderParser.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © Yan Zhenjie 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | package com.yanzhenjie.durban.util; 17 | 18 | import android.media.ExifInterface; 19 | import android.text.TextUtils; 20 | import android.util.Log; 21 | 22 | import java.io.IOException; 23 | import java.io.InputStream; 24 | import java.nio.ByteBuffer; 25 | import java.nio.ByteOrder; 26 | import java.nio.charset.Charset; 27 | 28 | /** 29 | * Update by Yan Zhenjie on 2017/5/23. 30 | */ 31 | public class ImageHeaderParser { 32 | private static final String TAG = "ImageHeaderParser"; 33 | /** 34 | * A constant indicating we were unable to parse the orientation from the image either because 35 | * no exif segment containing orientation data existed, or because of an I/O error attempting to 36 | * read the exif segment. 37 | */ 38 | public static final int UNKNOWN_ORIENTATION = -1; 39 | 40 | private static final int EXIF_MAGIC_NUMBER = 0xFFD8; 41 | // "MM". 42 | private static final int MOTOROLA_TIFF_MAGIC_NUMBER = 0x4D4D; 43 | // "II". 44 | private static final int INTEL_TIFF_MAGIC_NUMBER = 0x4949; 45 | private static final String JPEG_EXIF_SEGMENT_PREAMBLE = "Exif\0\0"; 46 | private static final byte[] JPEG_EXIF_SEGMENT_PREAMBLE_BYTES = 47 | JPEG_EXIF_SEGMENT_PREAMBLE.getBytes(Charset.forName("UTF-8")); 48 | private static final int SEGMENT_SOS = 0xDA; 49 | private static final int MARKER_EOI = 0xD9; 50 | private static final int SEGMENT_START_ID = 0xFF; 51 | private static final int EXIF_SEGMENT_TYPE = 0xE1; 52 | private static final int ORIENTATION_TAG_TYPE = 0x0112; 53 | private static final int[] BYTES_PER_FORMAT = {0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8}; 54 | 55 | private final Reader reader; 56 | 57 | public ImageHeaderParser(InputStream is) { 58 | reader = new StreamReader(is); 59 | } 60 | 61 | /** 62 | * Parse the orientation from the image header. If it doesn't handle this image type (or this is 63 | * not an image) it will return a default value rather than throwing an exception. 64 | * 65 | * @return The exif orientation if present or -1 if the header couldn't be parsed or doesn't 66 | * contain an orientation 67 | * @throws IOException 68 | */ 69 | public int getOrientation() throws IOException { 70 | final int magicNumber = reader.getUInt16(); 71 | 72 | if (!handles(magicNumber)) { 73 | if (Log.isLoggable(TAG, Log.DEBUG)) { 74 | Log.d(TAG, "Parser doesn't handle magic number: " + magicNumber); 75 | } 76 | return UNKNOWN_ORIENTATION; 77 | } else { 78 | int exifSegmentLength = moveToExifSegmentAndGetLength(); 79 | if (exifSegmentLength == -1) { 80 | if (Log.isLoggable(TAG, Log.DEBUG)) { 81 | Log.d(TAG, "Failed to parse exif segment length, or exif segment not found"); 82 | } 83 | return UNKNOWN_ORIENTATION; 84 | } 85 | 86 | byte[] exifData = new byte[exifSegmentLength]; 87 | return parseExifSegment(exifData, exifSegmentLength); 88 | } 89 | } 90 | 91 | private int parseExifSegment(byte[] tempArray, int exifSegmentLength) throws IOException { 92 | int read = reader.read(tempArray, exifSegmentLength); 93 | if (read != exifSegmentLength) { 94 | if (Log.isLoggable(TAG, Log.DEBUG)) { 95 | Log.d(TAG, "Unable to read exif segment data" 96 | + ", length: " + exifSegmentLength 97 | + ", actually read: " + read); 98 | } 99 | return UNKNOWN_ORIENTATION; 100 | } 101 | 102 | boolean hasJpegExifPreamble = hasJpegExifPreamble(tempArray, exifSegmentLength); 103 | if (hasJpegExifPreamble) { 104 | return parseExifSegment(new RandomAccessReader(tempArray, exifSegmentLength)); 105 | } else { 106 | if (Log.isLoggable(TAG, Log.DEBUG)) { 107 | Log.d(TAG, "Missing jpeg exif preamble"); 108 | } 109 | return UNKNOWN_ORIENTATION; 110 | } 111 | } 112 | 113 | private boolean hasJpegExifPreamble(byte[] exifData, int exifSegmentLength) { 114 | boolean result = 115 | exifData != null && exifSegmentLength > JPEG_EXIF_SEGMENT_PREAMBLE_BYTES.length; 116 | if (result) { 117 | for (int i = 0; i < JPEG_EXIF_SEGMENT_PREAMBLE_BYTES.length; i++) { 118 | if (exifData[i] != JPEG_EXIF_SEGMENT_PREAMBLE_BYTES[i]) { 119 | result = false; 120 | break; 121 | } 122 | } 123 | } 124 | return result; 125 | } 126 | 127 | /** 128 | * Moves reader to the start of the exif segment and returns the length of the exif segment or 129 | * {@code -1} if no exif segment is found. 130 | */ 131 | private int moveToExifSegmentAndGetLength() throws IOException { 132 | short segmentId, segmentType; 133 | int segmentLength; 134 | while (true) { 135 | segmentId = reader.getUInt8(); 136 | if (segmentId != SEGMENT_START_ID) { 137 | if (Log.isLoggable(TAG, Log.DEBUG)) { 138 | Log.d(TAG, "Unknown segmentId=" + segmentId); 139 | } 140 | return -1; 141 | } 142 | 143 | segmentType = reader.getUInt8(); 144 | 145 | if (segmentType == SEGMENT_SOS) { 146 | return -1; 147 | } else if (segmentType == MARKER_EOI) { 148 | if (Log.isLoggable(TAG, Log.DEBUG)) { 149 | Log.d(TAG, "Found MARKER_EOI in exif segment"); 150 | } 151 | return -1; 152 | } 153 | 154 | // Segment length includes bytes for segment length. 155 | segmentLength = reader.getUInt16() - 2; 156 | 157 | if (segmentType != EXIF_SEGMENT_TYPE) { 158 | long skipped = reader.skip(segmentLength); 159 | if (skipped != segmentLength) { 160 | if (Log.isLoggable(TAG, Log.DEBUG)) { 161 | Log.d(TAG, "Unable to skip enough data" 162 | + ", type: " + segmentType 163 | + ", wanted to skip: " + segmentLength 164 | + ", but actually skipped: " + skipped); 165 | } 166 | return -1; 167 | } 168 | } else { 169 | return segmentLength; 170 | } 171 | } 172 | } 173 | 174 | private static int parseExifSegment(RandomAccessReader segmentData) { 175 | final int headerOffsetSize = JPEG_EXIF_SEGMENT_PREAMBLE.length(); 176 | 177 | short byteOrderIdentifier = segmentData.getInt16(headerOffsetSize); 178 | final ByteOrder byteOrder; 179 | if (byteOrderIdentifier == MOTOROLA_TIFF_MAGIC_NUMBER) { 180 | byteOrder = ByteOrder.BIG_ENDIAN; 181 | } else if (byteOrderIdentifier == INTEL_TIFF_MAGIC_NUMBER) { 182 | byteOrder = ByteOrder.LITTLE_ENDIAN; 183 | } else { 184 | if (Log.isLoggable(TAG, Log.DEBUG)) { 185 | Log.d(TAG, "Unknown endianness = " + byteOrderIdentifier); 186 | } 187 | byteOrder = ByteOrder.BIG_ENDIAN; 188 | } 189 | 190 | segmentData.order(byteOrder); 191 | 192 | int firstIfdOffset = segmentData.getInt32(headerOffsetSize + 4) + headerOffsetSize; 193 | int tagCount = segmentData.getInt16(firstIfdOffset); 194 | 195 | int tagOffset, tagType, formatCode, componentCount; 196 | for (int i = 0; i < tagCount; i++) { 197 | tagOffset = calcTagOffset(firstIfdOffset, i); 198 | tagType = segmentData.getInt16(tagOffset); 199 | 200 | // We only want orientation. 201 | if (tagType != ORIENTATION_TAG_TYPE) { 202 | continue; 203 | } 204 | 205 | formatCode = segmentData.getInt16(tagOffset + 2); 206 | 207 | // 12 is max format code. 208 | if (formatCode < 1 || formatCode > 12) { 209 | if (Log.isLoggable(TAG, Log.DEBUG)) { 210 | Log.d(TAG, "Got invalid format code = " + formatCode); 211 | } 212 | continue; 213 | } 214 | 215 | componentCount = segmentData.getInt32(tagOffset + 4); 216 | 217 | if (componentCount < 0) { 218 | if (Log.isLoggable(TAG, Log.DEBUG)) { 219 | Log.d(TAG, "Negative tiff component count"); 220 | } 221 | continue; 222 | } 223 | 224 | if (Log.isLoggable(TAG, Log.DEBUG)) { 225 | Log.d(TAG, "Got tagIndex=" + i + " tagType=" + tagType + " formatCode=" + formatCode 226 | + " componentCount=" + componentCount); 227 | } 228 | 229 | final int byteCount = componentCount + BYTES_PER_FORMAT[formatCode]; 230 | 231 | if (byteCount > 4) { 232 | if (Log.isLoggable(TAG, Log.DEBUG)) { 233 | Log.d(TAG, "Got byte count > 4, not orientation, continuing, formatCode=" + formatCode); 234 | } 235 | continue; 236 | } 237 | 238 | final int tagValueOffset = tagOffset + 8; 239 | 240 | if (tagValueOffset < 0 || tagValueOffset > segmentData.length()) { 241 | if (Log.isLoggable(TAG, Log.DEBUG)) { 242 | Log.d(TAG, "Illegal tagValueOffset=" + tagValueOffset + " tagType=" + tagType); 243 | } 244 | continue; 245 | } 246 | 247 | if (byteCount < 0 || tagValueOffset + byteCount > segmentData.length()) { 248 | if (Log.isLoggable(TAG, Log.DEBUG)) { 249 | Log.d(TAG, "Illegal number of bytes for TI tag data tagType=" + tagType); 250 | } 251 | continue; 252 | } 253 | 254 | //assume componentCount == 1 && fmtCode == 3 255 | return segmentData.getInt16(tagValueOffset); 256 | } 257 | 258 | return -1; 259 | } 260 | 261 | private static int calcTagOffset(int ifdOffset, int tagIndex) { 262 | return ifdOffset + 2 + 12 * tagIndex; 263 | } 264 | 265 | private static boolean handles(int imageMagicNumber) { 266 | return (imageMagicNumber & EXIF_MAGIC_NUMBER) == EXIF_MAGIC_NUMBER 267 | || imageMagicNumber == MOTOROLA_TIFF_MAGIC_NUMBER 268 | || imageMagicNumber == INTEL_TIFF_MAGIC_NUMBER; 269 | } 270 | 271 | private static class RandomAccessReader { 272 | private final ByteBuffer data; 273 | 274 | public RandomAccessReader(byte[] data, int length) { 275 | this.data = (ByteBuffer) ByteBuffer.wrap(data) 276 | .order(ByteOrder.BIG_ENDIAN) 277 | .limit(length); 278 | } 279 | 280 | public void order(ByteOrder byteOrder) { 281 | this.data.order(byteOrder); 282 | } 283 | 284 | public int length() { 285 | return data.remaining(); 286 | } 287 | 288 | public int getInt32(int offset) { 289 | return data.getInt(offset); 290 | } 291 | 292 | public short getInt16(int offset) { 293 | return data.getShort(offset); 294 | } 295 | } 296 | 297 | private interface Reader { 298 | int getUInt16() throws IOException; 299 | 300 | short getUInt8() throws IOException; 301 | 302 | long skip(long total) throws IOException; 303 | 304 | int read(byte[] buffer, int byteCount) throws IOException; 305 | } 306 | 307 | private static class StreamReader implements Reader { 308 | private final InputStream is; 309 | 310 | // Motorola / big endian byte order. 311 | public StreamReader(InputStream is) { 312 | this.is = is; 313 | } 314 | 315 | @Override 316 | public int getUInt16() throws IOException { 317 | return (is.read() << 8 & 0xFF00) | (is.read() & 0xFF); 318 | } 319 | 320 | @Override 321 | public short getUInt8() throws IOException { 322 | return (short) (is.read() & 0xFF); 323 | } 324 | 325 | @Override 326 | public long skip(long total) throws IOException { 327 | if (total < 0) { 328 | return 0; 329 | } 330 | 331 | long toSkip = total; 332 | while (toSkip > 0) { 333 | long skipped = is.skip(toSkip); 334 | if (skipped > 0) { 335 | toSkip -= skipped; 336 | } else { 337 | // Skip has no specific contract as to what happens when you reach the end of 338 | // the stream. To differentiate between temporarily not having more data and 339 | // having finished the stream, we read a single byte when we fail to skip any 340 | // amount of data. 341 | int testEofByte = is.read(); 342 | if (testEofByte == -1) { 343 | break; 344 | } else { 345 | toSkip--; 346 | } 347 | } 348 | } 349 | return total - toSkip; 350 | } 351 | 352 | @Override 353 | public int read(byte[] buffer, int byteCount) throws IOException { 354 | int toRead = byteCount; 355 | int read; 356 | while (toRead > 0 && ((read = is.read(buffer, byteCount - toRead, toRead)) != -1)) { 357 | toRead -= read; 358 | } 359 | return byteCount - toRead; 360 | } 361 | } 362 | 363 | public static void copyExif(ExifInterface originalExif, int width, int height, String imageOutputPath) { 364 | String[] attributes = new String[]{ 365 | ExifInterface.TAG_APERTURE, 366 | ExifInterface.TAG_DATETIME, 367 | ExifInterface.TAG_DATETIME_DIGITIZED, 368 | ExifInterface.TAG_EXPOSURE_TIME, 369 | ExifInterface.TAG_FLASH, 370 | ExifInterface.TAG_FOCAL_LENGTH, 371 | ExifInterface.TAG_GPS_ALTITUDE, 372 | ExifInterface.TAG_GPS_ALTITUDE_REF, 373 | ExifInterface.TAG_GPS_DATESTAMP, 374 | ExifInterface.TAG_GPS_LATITUDE, 375 | ExifInterface.TAG_GPS_LATITUDE_REF, 376 | ExifInterface.TAG_GPS_LONGITUDE, 377 | ExifInterface.TAG_GPS_LONGITUDE_REF, 378 | ExifInterface.TAG_GPS_PROCESSING_METHOD, 379 | ExifInterface.TAG_GPS_TIMESTAMP, 380 | ExifInterface.TAG_ISO, 381 | ExifInterface.TAG_MAKE, 382 | ExifInterface.TAG_MODEL, 383 | ExifInterface.TAG_SUBSEC_TIME, 384 | ExifInterface.TAG_SUBSEC_TIME_DIG, 385 | ExifInterface.TAG_SUBSEC_TIME_ORIG, 386 | ExifInterface.TAG_WHITE_BALANCE 387 | }; 388 | 389 | try { 390 | ExifInterface newExif = new ExifInterface(imageOutputPath); 391 | String value; 392 | for (String attribute : attributes) { 393 | value = originalExif.getAttribute(attribute); 394 | if (!TextUtils.isEmpty(value)) { 395 | newExif.setAttribute(attribute, value); 396 | } 397 | } 398 | newExif.setAttribute(ExifInterface.TAG_IMAGE_WIDTH, String.valueOf(width)); 399 | newExif.setAttribute(ExifInterface.TAG_IMAGE_LENGTH, String.valueOf(height)); 400 | newExif.setAttribute(ExifInterface.TAG_ORIENTATION, "0"); 401 | 402 | newExif.saveAttributes(); 403 | 404 | } catch (IOException e) { 405 | Log.d(TAG, e.getMessage()); 406 | } 407 | } 408 | 409 | } 410 | 411 | -------------------------------------------------------------------------------- /durban/src/main/java/com/yanzhenjie/durban/DurbanActivity.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright © Yan Zhenjie 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | package com.yanzhenjie.durban; 17 | 18 | import android.Manifest; 19 | import android.content.Intent; 20 | import android.content.pm.PackageManager; 21 | import android.graphics.Bitmap; 22 | import android.os.Build; 23 | import android.os.Bundle; 24 | import android.support.annotation.NonNull; 25 | import android.support.v4.app.ActivityCompat; 26 | import android.support.v4.content.ContextCompat; 27 | import android.support.v4.view.ViewCompat; 28 | import android.support.v7.app.ActionBar; 29 | import android.support.v7.app.AppCompatActivity; 30 | import android.support.v7.widget.Toolbar; 31 | import android.text.TextUtils; 32 | import android.util.Log; 33 | import android.view.Menu; 34 | import android.view.MenuItem; 35 | import android.view.View; 36 | import android.view.Window; 37 | import android.view.WindowManager; 38 | import android.view.animation.AccelerateInterpolator; 39 | 40 | import com.yanzhenjie.durban.callback.BitmapCropCallback; 41 | import com.yanzhenjie.durban.util.DurbanUtils; 42 | import com.yanzhenjie.durban.view.CropView; 43 | import com.yanzhenjie.durban.view.GestureCropImageView; 44 | import com.yanzhenjie.durban.view.OverlayView; 45 | import com.yanzhenjie.durban.view.TransformImageView; 46 | 47 | import java.util.ArrayList; 48 | import java.util.Locale; 49 | 50 | /** 51 | * Update by Yan Zhenjie on 2017/5/23. 52 | */ 53 | public class DurbanActivity extends AppCompatActivity { 54 | 55 | private static final int PERMISSION_CODE_STORAGE = 1; 56 | 57 | private int mStatusColor; 58 | private int mNavigationColor; 59 | private int mToolbarColor; 60 | private String mTitle; 61 | 62 | private int mGesture; 63 | private float[] mAspectRatio; 64 | private int[] mMaxWidthHeight; 65 | 66 | private Bitmap.CompressFormat mCompressFormat; 67 | private int mCompressQuality; 68 | 69 | private String mOutputDirectory; 70 | private ArrayList