Master non native - Githubissues

package com.yalantis.ucrop.task;

import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.graphics.Matrix; import android.net.Uri; import android.os.AsyncTask; import android.util.Log;

import androidx.annotation.NonNull; import androidx.annotation.Nullable;

import com.yalantis.ucrop.callback.BitmapLoadCallback; import com.yalantis.ucrop.model.ExifInfo; import com.yalantis.ucrop.util.BitmapLoadUtils;

import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream;

import okhttp3.OkHttpClient; import okhttp3.Request; import okhttp3.Response; import okio.BufferedSource; import okio.Okio; import okio.Sink;

/**

Creates and returns a Bitmap for a given Uri(String url).
inSampleSize is calculated based on requiredWidth property. However can be adjusted if OOM occurs.

If any EXIF config is found - bitmap is transformed properly. */ public class BitmapLoadTask extends AsyncTask<Void, Void, BitmapLoadTask.BitmapWorkerResult> {

private static final String TAG = "BitmapWorkerTask";

private final Context mContext; private Uri mInputUri; private Uri mOutputUri; private final int mRequiredWidth; private final int mRequiredHeight;

private final BitmapLoadCallback mBitmapLoadCallback;

public static class BitmapWorkerResult {

Bitmap mBitmapResult;
ExifInfo mExifInfo;
Exception mBitmapWorkerException;

public BitmapWorkerResult(@NonNull Bitmap bitmapResult, @NonNull ExifInfo exifInfo) {
    mBitmapResult = bitmapResult;
    mExifInfo = exifInfo;
}

public BitmapWorkerResult(@NonNull Exception bitmapWorkerException) {
    mBitmapWorkerException = bitmapWorkerException;
}

}

public BitmapLoadTask(@NonNull Context context, @NonNull Uri inputUri, @Nullable Uri outputUri, int requiredWidth, int requiredHeight, BitmapLoadCallback loadCallback) { mContext = context; mInputUri = inputUri; mOutputUri = outputUri; mRequiredWidth = requiredWidth; mRequiredHeight = requiredHeight; mBitmapLoadCallback = loadCallback; }

@Override @NonNull protected BitmapWorkerResult doInBackground(Void... params) { if (mInputUri == null) { return new BitmapWorkerResult(new NullPointerException("Input Uri cannot be null")); }

try {
    processInputUri();
} catch (NullPointerException | IOException e) {
    return new BitmapWorkerResult(e);
}

final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
try {
    BitmapFactory.decodeStream(mContext.getContentResolver().openInputStream(mInputUri) ,null, options);
} catch (FileNotFoundException e) {
    e.printStackTrace();
}
options.inSampleSize = BitmapLoadUtils.calculateInSampleSize(options, mRequiredWidth, mRequiredHeight);
options.inJustDecodeBounds = false;

Bitmap decodeSampledBitmap = null;

boolean decodeAttemptSuccess = false;
while (!decodeAttemptSuccess) {
    try {
        InputStream stream = mContext.getContentResolver().openInputStream(mInputUri);
        try {
            decodeSampledBitmap = BitmapFactory.decodeStream(stream, null, options);
            if (options.outWidth == -1 || options.outHeight == -1) {
                return new BitmapWorkerResult(new IllegalArgumentException("Bounds for bitmap could not be retrieved from the Uri: [" + mInputUri + "]"));
            }
        } finally {
            BitmapLoadUtils.close(stream);
        }
        decodeAttemptSuccess = true;
    } catch (OutOfMemoryError error) {
        Log.e(TAG, "doInBackground: BitmapFactory.decodeFileDescriptor: ", error);
        options.inSampleSize *= 2;
    } catch (IOException e) {
        Log.e(TAG, "doInBackground: ImageDecoder.createSource: ", e);
        return new BitmapWorkerResult(new IllegalArgumentException("Bitmap could not be decoded from the Uri: [" + mInputUri + "]", e));
    }
}

if (decodeSampledBitmap == null) {
    return new BitmapWorkerResult(new IllegalArgumentException("Bitmap could not be decoded from the Uri: [" + mInputUri + "]"));
}

int exifOrientation = BitmapLoadUtils.getExifOrientation(mContext, mInputUri);
int exifDegrees = BitmapLoadUtils.exifToDegrees(exifOrientation);
int exifTranslation = BitmapLoadUtils.exifToTranslation(exifOrientation);

ExifInfo exifInfo = new ExifInfo(exifOrientation, exifDegrees, exifTranslation);

Matrix matrix = new Matrix();
if (exifDegrees != 0) {
    matrix.preRotate(exifDegrees);
}
if (exifTranslation != 1) {
    matrix.postScale(exifTranslation, 1);
}
if (!matrix.isIdentity()) {
    return new BitmapWorkerResult(BitmapLoadUtils.transformBitmap(decodeSampledBitmap, matrix), exifInfo);
}

return new BitmapWorkerResult(decodeSampledBitmap, exifInfo);

}

private void processInputUri() throws NullPointerException, IOException { String inputUriScheme = mInputUri.getScheme(); Log.d(TAG, "Uri scheme: " + inputUriScheme); if ("http".equals(inputUriScheme) || "https".equals(inputUriScheme)) { try { downloadFile(mInputUri, mOutputUri); } catch (NullPointerException | IOException e) { Log.e(TAG, "Downloading failed", e); throw e; } } else if ("content".equals(inputUriScheme)) { try { copyFile(mInputUri, mOutputUri); } catch (NullPointerException | IOException e) { Log.e(TAG, "Copying failed", e); throw e; } } else if (!"file".equals(inputUriScheme)) { Log.e(TAG, "Invalid Uri scheme " + inputUriScheme); throw new IllegalArgumentException("Invalid Uri scheme" + inputUriScheme); } }

private void copyFile(@NonNull Uri inputUri, @Nullable Uri outputUri) throws NullPointerException, IOException { Log.d(TAG, "copyFile");

if (outputUri == null) {
    throw new NullPointerException("Output Uri is null - cannot copy image");
}

InputStream inputStream = null;
OutputStream outputStream = null;
try {
    inputStream = mContext.getContentResolver().openInputStream(inputUri);
    outputStream = new FileOutputStream(new File(outputUri.getPath()));
    if (inputStream == null) {
        throw new NullPointerException("InputStream for given input Uri is null");
    }

    byte buffer[] = new byte[1024];
    int length;
    while ((length = inputStream.read(buffer)) > 0) {
        outputStream.write(buffer, 0, length);
    }
} finally {
    BitmapLoadUtils.close(outputStream);
    BitmapLoadUtils.close(inputStream);

    // swap uris, because input image was copied to the output destination
    // (cropped image will override it later)
    mInputUri = mOutputUri;
}

}

private void downloadFile(@NonNull Uri inputUri, @Nullable Uri outputUri) throws NullPointerException, IOException { Log.d(TAG, "downloadFile");

if (outputUri == null) {
    throw new NullPointerException("Output Uri is null - cannot download image");
}

OkHttpClient client = new OkHttpClient();

BufferedSource source = null;
Sink sink = null;
Response response = null;
try {
    Request request = new Request.Builder()
            .url(inputUri.toString())
            .build();
    response = client.newCall(request).execute();
    source = response.body().source();

    OutputStream outputStream = mContext.getContentResolver().openOutputStream(outputUri);
    if (outputStream != null) {
        sink = Okio.sink(outputStream);
        source.readAll(sink);
    } else {
        throw new NullPointerException("OutputStream for given output Uri is null");
    }
} finally {
    BitmapLoadUtils.close(source);
    BitmapLoadUtils.close(sink);
    if (response != null) {
        BitmapLoadUtils.close(response.body());
    }
    client.dispatcher().cancelAll();

    // swap uris, because input image was downloaded to the output destination
    // (cropped image will override it later)
    mInputUri = mOutputUri;
}

}

@Override protected void onPostExecute(@NonNull BitmapWorkerResult result) { if (result.mBitmapWorkerException == null) { mBitmapLoadCallback.onBitmapLoaded(result.mBitmapResult, result.mExifInfo, mInputUri.getPath(), (mOutputUri == null) ? null : mOutputUri.getPath()); } else { mBitmapLoadCallback.onFailure(result.mBitmapWorkerException); } }

}

Yalantis / uCrop

Master non native #756