Removed native part.

ucrop/build.gradle

@@ -29,10 +29,6 @@ android {
 
     resourcePrefix 'ucrop_'
 
-    sourceSets.main {
-        jni.srcDirs = [];
-    }
-
 }
 
 dependencies {

ucrop/src/main/java/com/yalantis/ucrop/task/BitmapCropTask.java

@@ -1,7 +1,8 @@
 package com.yalantis.ucrop.task;
 
+import android.content.Context;
 import android.graphics.Bitmap;
-import android.graphics.BitmapFactory;
+import android.graphics.Matrix;
 import android.graphics.RectF;
 import android.media.ExifInterface;
 import android.net.Uri;
@@ -14,11 +15,15 @@
 import com.yalantis.ucrop.model.CropParameters;
 import com.yalantis.ucrop.model.ExifInfo;
 import com.yalantis.ucrop.model.ImageState;
+import com.yalantis.ucrop.util.BitmapLoadUtils;
 import com.yalantis.ucrop.util.FileUtils;
 import com.yalantis.ucrop.util.ImageHeaderParser;
 
 import java.io.File;
+import java.io.FileNotFoundException;
 import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.ref.WeakReference;
 
 /**
  * Crops part of image that fills the crop bounds.
@@ -31,9 +36,7 @@ public class BitmapCropTask extends AsyncTask<Void, Void, Throwable> {
 
     private static final String TAG = "BitmapCropTask";
 
-    static {
-        System.loadLibrary("ucrop");
-    }
+    private final WeakReference<Context> mContext;
 
     private Bitmap mViewBitmap;
 
@@ -51,9 +54,11 @@ public class BitmapCropTask extends AsyncTask<Void, Void, Throwable> {
 
     private int mCroppedImageWidth, mCroppedImageHeight;
 
-    public BitmapCropTask(@Nullable Bitmap viewBitmap, @NonNull ImageState imageState, @NonNull CropParameters cropParameters,
+    public BitmapCropTask(@NonNull Context context, @Nullable Bitmap viewBitmap, @NonNull ImageState imageState, @NonNull CropParameters cropParameters,
                           @Nullable BitmapCropCallback cropCallback) {
 
+        mContext = new WeakReference<>(context);
+
         mViewBitmap = viewBitmap;
         mCropRect = imageState.getCropRect();
         mCurrentImageRect = imageState.getCurrentImageRect();
@@ -84,10 +89,9 @@ protected Throwable doInBackground(Void... params) {
             return new NullPointerException("CurrentImageRect is empty");
         }
 
-        float resizeScale = resize();
 
         try {
-            crop(resizeScale);
+            crop();
             mViewBitmap = null;
         } catch (Throwable throwable) {
             return throwable;
@@ -96,38 +100,43 @@ protected Throwable doInBackground(Void... params) {
         return null;
     }
 
-    private float resize() {
-        final BitmapFactory.Options options = new BitmapFactory.Options();
-        options.inJustDecodeBounds = true;
-        BitmapFactory.decodeFile(mImageInputPath, options);
-
-        boolean swapSides = mExifInfo.getExifDegrees() == 90 || mExifInfo.getExifDegrees() == 270;
-        float scaleX = (swapSides ? options.outHeight : options.outWidth) / (float) mViewBitmap.getWidth();
-        float scaleY = (swapSides ? options.outWidth : options.outHeight) / (float) mViewBitmap.getHeight();
-
-        float resizeScale = Math.min(scaleX, scaleY);
-
-        mCurrentScale /= resizeScale;
 
-        resizeScale = 1;
+    private boolean crop() throws IOException {
+        // Downsize if needed
         if (mMaxResultImageSizeX > 0 && mMaxResultImageSizeY > 0) {
             float cropWidth = mCropRect.width() / mCurrentScale;
             float cropHeight = mCropRect.height() / mCurrentScale;
 
             if (cropWidth > mMaxResultImageSizeX || cropHeight > mMaxResultImageSizeY) {
 
-                scaleX = mMaxResultImageSizeX / cropWidth;
-                scaleY = mMaxResultImageSizeY / cropHeight;
-                resizeScale = Math.min(scaleX, scaleY);
+                float scaleX = mMaxResultImageSizeX / cropWidth;
+                float scaleY = mMaxResultImageSizeY / cropHeight;
+                float resizeScale = Math.min(scaleX, scaleY);
+
+                Bitmap resizedBitmap = Bitmap.createScaledBitmap(mViewBitmap,
+                        Math.round(mViewBitmap.getWidth() * resizeScale),
+                        Math.round(mViewBitmap.getHeight() * resizeScale), false);
+                if (mViewBitmap != resizedBitmap) {
+                    mViewBitmap.recycle();
+                }
+                mViewBitmap = resizedBitmap;
 
                 mCurrentScale /= resizeScale;
             }
         }
-        return resizeScale;
-    }
 
-    private boolean crop(float resizeScale) throws IOException {
-        ExifInterface originalExif = new ExifInterface(mImageInputPath);
+        // Rotate if needed
+        if (mCurrentAngle != 0) {
+            Matrix tempMatrix = new Matrix();
+            tempMatrix.setRotate(mCurrentAngle, mViewBitmap.getWidth() / 2, mViewBitmap.getHeight() / 2);
+
+            Bitmap rotatedBitmap = Bitmap.createBitmap(mViewBitmap, 0, 0, mViewBitmap.getWidth(), mViewBitmap.getHeight(),
+                    tempMatrix, true);
+            if (mViewBitmap != rotatedBitmap) {
+                mViewBitmap.recycle();
+            }
+            mViewBitmap = rotatedBitmap;
+        }
 
         int top = Math.round((mCropRect.top - mCurrentImageRect.top) / mCurrentScale);
         int left = Math.round((mCropRect.left - mCurrentImageRect.left) / mCurrentScale);
@@ -138,20 +147,34 @@ private boolean crop(float resizeScale) throws IOException {
         Log.i(TAG, "Should crop: " + shouldCrop);
 
         if (shouldCrop) {
-            boolean cropped = cropCImg(mImageInputPath, mImageOutputPath,
-                    left, top, mCroppedImageWidth, mCroppedImageHeight, mCurrentAngle, resizeScale,
-                    mCompressFormat.ordinal(), mCompressQuality,
-                    mExifInfo.getExifDegrees(), mExifInfo.getExifTranslation());
-            if (cropped && mCompressFormat.equals(Bitmap.CompressFormat.JPEG)) {
+            ExifInterface originalExif = new ExifInterface(mImageInputPath);
+            saveImage(Bitmap.createBitmap(mViewBitmap, left, top, mCroppedImageWidth, mCroppedImageHeight));
+            if (mCompressFormat.equals(Bitmap.CompressFormat.JPEG)) {
                 ImageHeaderParser.copyExif(originalExif, mCroppedImageWidth, mCroppedImageHeight, mImageOutputPath);
             }
-            return cropped;
+            return true;
         } else {
             FileUtils.copyFile(mImageInputPath, mImageOutputPath);
             return false;
         }
     }
 
+    private void saveImage(@NonNull Bitmap croppedBitmap) throws FileNotFoundException {
+        Context context = mContext.get();
+        if (context == null) {
+            return;
+        }
+
+        OutputStream outputStream = null;
+        try {
+            outputStream = context.getContentResolver().openOutputStream(Uri.fromFile(new File(mImageOutputPath)));
+            croppedBitmap.compress(mCompressFormat, mCompressQuality, outputStream);
+            croppedBitmap.recycle();
+        } finally {
+            BitmapLoadUtils.close(outputStream);
+        }
+    }
+
     /**
      * Check whether an image should be cropped at all or just file can be copied to the destination path.
      * For each 1000 pixels there is one pixel of error due to matrix calculations etc.
@@ -170,14 +193,6 @@ private boolean shouldCrop(int width, int height) {
                 || Math.abs(mCropRect.right - mCurrentImageRect.right) > pixelError;
     }
 
-    @SuppressWarnings("JniMissingFunction")
-    native public boolean
-    cropCImg(String inputPath, String outputPath,
-             int left, int top, int width, int height,
-             float angle, float resizeScale,
-             int format, int quality,
-             int exifDegrees, int exifTranslation) throws IOException, OutOfMemoryError;
-
     @Override
     protected void onPostExecute(@Nullable Throwable t) {
         if (mCropCallback != null) {

ucrop/src/main/java/com/yalantis/ucrop/view/CropImageView.java

@@ -82,7 +82,7 @@ public void cropAndSaveImage(@NonNull Bitmap.CompressFormat compressFormat, int
                 compressFormat, compressQuality,
                 getImageInputPath(), getImageOutputPath(), getExifInfo());
 
-        new BitmapCropTask(getViewBitmap(), imageState, cropParameters, cropCallback).execute();
+        new BitmapCropTask(getContext(), getViewBitmap(), imageState, cropParameters, cropCallback).execute();
     }
 
     /**