工作空间 v3.6.5.2版本的 MD5 值为：58e65af156c65a63bf64ed2e64960853

以下内容为反编译后的 PhotoUtils.java 源代码，内容仅作参考

package com.uusafe.utils.common;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.ContentResolver;
import android.content.ContentUris;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffXfermode;
import android.graphics.Rect;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import android.media.ExifInterface;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.DocumentsContract;
import android.provider.MediaStore;
import androidx.fragment.app.Fragment;
import com.uusafe.base.sandboxsdk.env.PortalSandboxHelper;
import com.uusafe.h5app.library.api.IConstants;
import com.uusafe.secamera.common.Const;
import com.xiaomi.mipush.sdk.Constants;
import com.zhizhangyi.platform.mdm.api.common.ResultConst;
import com.zhizhangyi.platform.network.download.internal.Downloads;
import com.zhizhangyi.platform.zwebview.AgentWebPermissions;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
public class PhotoUtils {
    private static final String TAG = "PhotoUtils";

    public static void adjustPhoto(String str, int i) throws FileNotFoundException {
        Bitmap decodeFile = BitmapFactory.decodeFile(str);
        if (decodeFile == null) {
            return;
        }
        Bitmap adjustedBitmap = getAdjustedBitmap(decodeFile, str);
        FileOutputStream fileOutputStream = new FileOutputStream(str);
        if (adjustedBitmap != null) {
            adjustedBitmap.compress(Bitmap.CompressFormat.JPEG, i, fileOutputStream);
        }
        IOUtils.closeQuietly((OutputStream) fileOutputStream);
    }

    public static Bitmap bimapRound(Bitmap bitmap, float f) {
        Bitmap createBitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.Config.ARGB_8888);
        Canvas canvas = new Canvas(createBitmap);
        Paint paint = new Paint();
        paint.setAntiAlias(true);
        Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight());
        RectF rectF = new RectF(rect);
        canvas.drawARGB(0, 0, 0, 0);
        canvas.drawRoundRect(rectF, f, f, paint);
        paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
        canvas.drawBitmap(bitmap, rect, rect, paint);
        return createBitmap;
    }

    public static void cropImageUri(Activity activity, Uri uri, Uri uri2, int i, int i2, int i3, int i4, int i5) {
        Intent intent = new Intent("com.android.camera.action.CROP");
        if (Build.VERSION.SDK_INT >= 24) {
            intent.addFlags(1);
        }
        intent.setDataAndType(uri, IConstants.ACCEPT_TYPE_IMAGE);
        intent.putExtra("crop", "true");
        intent.putExtra("aspectX", i);
        intent.putExtra("aspectY", i2);
        intent.putExtra("outputX", i3);
        intent.putExtra("outputY", i4);
        intent.putExtra("scale", true);
        intent.putExtra("output", uri2);
        intent.putExtra("return-data", false);
        intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
        intent.putExtra("noFaceDetection", true);
        activity.startActivityForResult(intent, i5);
    }

    public static Bitmap drawableToBitmap(Drawable drawable) {
        int intrinsicWidth = drawable.getIntrinsicWidth();
        int intrinsicHeight = drawable.getIntrinsicHeight();
        if (intrinsicWidth <= 0 || intrinsicHeight <= 0) {
            return null;
        }
        Bitmap createBitmap = Bitmap.createBitmap(intrinsicWidth, intrinsicHeight, drawable.getOpacity() != -1 ? Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565);
        Canvas canvas = new Canvas(createBitmap);
        drawable.setBounds(0, 0, intrinsicWidth, intrinsicHeight);
        drawable.draw(canvas);
        return createBitmap;
    }

    private static int exifToDegrees(int i) {
        if (i == 6) {
            return 90;
        }
        if (i == 3) {
            return ResultConst.Type.sIsChangeWallPaperDisabled;
        }
        if (i == 8) {
            return ResultConst.Type.sSetVpnDisabled;
        }
        return 0;
    }

    private static Bitmap getAdjustedBitmap(Bitmap bitmap, String str) {
        if (bitmap == null) {
            return null;
        }
        try {
            int attributeInt = new ExifInterface(str).getAttributeInt(androidx.exifinterface.media.ExifInterface.TAG_ORIENTATION, 1);
            int exifToDegrees = exifToDegrees(attributeInt);
            Matrix matrix = new Matrix();
            if (attributeInt != 0.0f) {
                matrix.preRotate(exifToDegrees);
            }
            return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
        } catch (IOException e2) {
            e2.printStackTrace();
            return bitmap;
        }
    }

    public static Bitmap getBitmapFromUri(Uri uri, Context context) {
        try {
            return MediaStore.Images.Media.getBitmap(context.getContentResolver(), uri);
        } catch (Exception e2) {
            e2.printStackTrace();
            return null;
        }
    }

    private static String getDataColumn(Context context, Uri uri, String str, String[] strArr) {
        Cursor cursor;
        try {
            cursor = context.getContentResolver().query(uri, new String[]{Downloads.Impl._DATA}, str, strArr, null);
            if (cursor != null) {
                try {
                    if (cursor.moveToFirst()) {
                        String string = cursor.getString(cursor.getColumnIndexOrThrow(Downloads.Impl._DATA));
                        if (cursor != null) {
                            cursor.close();
                        }
                        return string;
                    }
                } catch (Throwable th) {
                    th = th;
                    if (cursor != null) {
                        cursor.close();
                    }
                    throw th;
                }
            }
            if (cursor != null) {
                cursor.close();
            }
            return null;
        } catch (Throwable th2) {
            th = th2;
            cursor = null;
        }
    }

    @SuppressLint({"NewApi"})
    public static String getPath(Context context, Uri uri) {
        Uri uri2 = null;
        if ((Build.VERSION.SDK_INT >= 19) && DocumentsContract.isDocumentUri(context, uri)) {
            if (isExternalStorageDocument(uri)) {
                String[] split = DocumentsContract.getDocumentId(uri).split(Constants.COLON_SEPARATOR);
                if ("primary".equalsIgnoreCase(split[0])) {
                    return "file:///" + Environment.getExternalStorageDirectory() + "/" + split[1];
                }
            } else if (isDownloadsDocument(uri)) {
                Uri withAppendedId = ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"), Long.valueOf(DocumentsContract.getDocumentId(uri)).longValue());
                return "file:///" + getDataColumn(context, withAppendedId, null, null);
            } else if (isMediaDocument(uri)) {
                String[] split2 = DocumentsContract.getDocumentId(uri).split(Constants.COLON_SEPARATOR);
                String str = split2[0];
                if ("image".equals(str)) {
                    uri2 = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
                } else if (Const.TAG_VIDEO.equals(str)) {
                    uri2 = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
                } else if (PortalSandboxHelper.PERMISSION_AUDIO.equals(str)) {
                    uri2 = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
                }
                String[] strArr = {split2[1]};
                return "file:///" + getDataColumn(context, uri2, "_id=?", strArr);
            }
        } else if ("content".equalsIgnoreCase(uri.getScheme())) {
            return "file:///" + getDataColumn(context, uri, null, null);
        } else if ("file".equalsIgnoreCase(uri.getScheme())) {
            return "file:///" + uri.getPath();
        }
        return null;
    }

    public static final String insertImage(ContentResolver contentResolver, String str, String str2, String str3) throws FileNotFoundException {
        FileInputStream fileInputStream = new FileInputStream(str);
        try {
            Bitmap decodeFile = BitmapFactory.decodeFile(str);
            String insertImage = insertImage(contentResolver, decodeFile, str2, str3);
            decodeFile.recycle();
            return insertImage;
        } finally {
            try {
                fileInputStream.close();
            } catch (IOException unused) {
            }
        }
    }

    private static boolean isDownloadsDocument(Uri uri) {
        return "com.android.providers.downloads.documents".equals(uri.getAuthority());
    }

    private static boolean isExternalStorageDocument(Uri uri) {
        return "com.android.externalstorage.documents".equals(uri.getAuthority());
    }

    private static boolean isMediaDocument(Uri uri) {
        return "com.android.providers.media.documents".equals(uri.getAuthority());
    }

    public static void pickPhoto(Activity activity, int i) {
        Intent intent = new Intent("android.intent.action.GET_CONTENT");
        intent.setType(IConstants.ACCEPT_TYPE_IMAGE);
        activity.startActivityForResult(intent, i);
    }

    public static String saveBmp2Gallery(Bitmap bitmap, String str, Context context) {
        File file;
        FileOutputStream fileOutputStream;
        FileOutputStream fileOutputStream2 = null;
        r0 = null;
        FileOutputStream fileOutputStream3 = null;
        fileOutputStream2 = null;
        File file2 = null;
        try {
            try {
                try {
                    try {
                        file = new File(Environment.getExternalStorageDirectory() + File.separator + Environment.DIRECTORY_DCIM + File.separator + AgentWebPermissions.ACTION_CAMERA + File.separator, str);
                        try {
                            fileOutputStream = new FileOutputStream(file.toString());
                        } catch (Exception e2) {
                            e = e2;
                        }
                    } catch (Exception e3) {
                        e = e3;
                        file = null;
                    } catch (Throwable th) {
                        th = th;
                        file = null;
                    }
                } catch (Throwable th2) {
                    th = th2;
                }
            } catch (Exception e4) {
                e = e4;
                file2 = file;
                e.printStackTrace();
                if (file2 == null) {
                }
            }
        } catch (Exception e5) {
            e = e5;
            e.printStackTrace();
            if (file2 == null) {
            }
        }
        try {
            fileOutputStream2 = 90;
            bitmap.compress(Bitmap.CompressFormat.PNG, 90, fileOutputStream);
            try {
                fileOutputStream.close();
            } catch (IOException e6) {
                e = e6;
                e.printStackTrace();
                file2 = file;
                Intent intent = new Intent("android.intent.action.MEDIA_SCANNER_SCAN_FILE");
                intent.setData(Uri.fromFile(file2));
                context.sendBroadcast(intent);
                if (file2 == null) {
                }
            }
        } catch (Exception e7) {
            e = e7;
            fileOutputStream3 = fileOutputStream;
            e.getStackTrace();
            fileOutputStream2 = fileOutputStream3;
            if (fileOutputStream3 != null) {
                try {
                    fileOutputStream3.close();
                    fileOutputStream2 = fileOutputStream3;
                } catch (IOException e8) {
                    e = e8;
                    e.printStackTrace();
                    file2 = file;
                    Intent intent2 = new Intent("android.intent.action.MEDIA_SCANNER_SCAN_FILE");
                    intent2.setData(Uri.fromFile(file2));
                    context.sendBroadcast(intent2);
                    if (file2 == null) {
                    }
                }
            }
            file2 = file;
            Intent intent22 = new Intent("android.intent.action.MEDIA_SCANNER_SCAN_FILE");
            intent22.setData(Uri.fromFile(file2));
            context.sendBroadcast(intent22);
            if (file2 == null) {
            }
        } catch (Throwable th3) {
            th = th3;
            fileOutputStream2 = fileOutputStream;
            if (fileOutputStream2 != null) {
                try {
                    fileOutputStream2.close();
                } catch (IOException e9) {
                    e9.printStackTrace();
                }
            }
            throw th;
        }
        file2 = file;
        Intent intent222 = new Intent("android.intent.action.MEDIA_SCANNER_SCAN_FILE");
        intent222.setData(Uri.fromFile(file2));
        context.sendBroadcast(intent222);
        return file2 == null ? file2.getAbsolutePath() : "";
    }

    private static final Bitmap storeThumbnail(ContentResolver contentResolver, Bitmap bitmap, long j, float f, float f2, int i) {
        Matrix matrix = new Matrix();
        matrix.setScale(f / bitmap.getWidth(), f2 / bitmap.getHeight());
        Bitmap createBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
        ContentValues contentValues = new ContentValues(4);
        contentValues.put("kind", Integer.valueOf(i));
        contentValues.put("image_id", Integer.valueOf((int) j));
        contentValues.put("height", Integer.valueOf(createBitmap.getHeight()));
        contentValues.put("width", Integer.valueOf(createBitmap.getWidth()));
        try {
            OutputStream openOutputStream = contentResolver.openOutputStream(contentResolver.insert(MediaStore.Images.Thumbnails.EXTERNAL_CONTENT_URI, contentValues));
            createBitmap.compress(Bitmap.CompressFormat.JPEG, 100, openOutputStream);
            openOutputStream.close();
            return createBitmap;
        } catch (FileNotFoundException | IOException unused) {
            return null;
        }
    }

    public static void takePhoto(Activity activity, Uri uri, int i) {
        Intent intent = new Intent();
        intent.setAction("android.media.action.IMAGE_CAPTURE");
        intent.putExtra("output", uri);
        intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
        activity.startActivityForResult(intent, i);
    }

    public static void pickPhoto(Fragment fragment, int i) {
        Intent intent = new Intent("android.intent.action.GET_CONTENT");
        intent.setType(IConstants.ACCEPT_TYPE_IMAGE);
        fragment.startActivityForResult(intent, i);
    }

    public static void takePhoto(Fragment fragment, Uri uri, int i) {
        Intent intent = new Intent();
        intent.setAction("android.media.action.IMAGE_CAPTURE");
        intent.putExtra("output", uri);
        intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
        fragment.startActivityForResult(intent, i);
    }

    public static final String insertImage(ContentResolver contentResolver, Bitmap bitmap, String str, String str2) {
        Uri uri;
        ContentValues contentValues = new ContentValues();
        contentValues.put("title", str);
        contentValues.put("_display_name", str);
        contentValues.put("description", str2);
        contentValues.put("mime_type", "image/jpeg");
        contentValues.put("date_added", Long.valueOf(System.currentTimeMillis() / 1000));
        contentValues.put("datetaken", Long.valueOf(System.currentTimeMillis()));
        try {
            uri = contentResolver.insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, contentValues);
        } catch (Exception unused) {
            uri = null;
        }
        try {
        } catch (Exception unused2) {
            if (uri != null) {
                contentResolver.delete(uri, null, null);
                uri = null;
            }
            if (uri != null) {
            }
        }
        if (bitmap != null) {
            OutputStream openOutputStream = contentResolver.openOutputStream(uri);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 50, openOutputStream);
            openOutputStream.close();
            long parseId = ContentUris.parseId(uri);
            storeThumbnail(contentResolver, MediaStore.Images.Thumbnails.getThumbnail(contentResolver, parseId, 1, null), parseId, 50.0f, 50.0f, 3);
            if (uri != null) {
                return uri.toString();
            }
            return null;
        }
        contentResolver.delete(uri, null, null);
        uri = null;
        if (uri != null) {
        }
    }

    public static void cropImageUri(Fragment fragment, Uri uri, Uri uri2, int i, int i2, int i3, int i4, int i5) {
        Intent intent = new Intent("com.android.imageselector_camera.action.CROP");
        if (Build.VERSION.SDK_INT >= 24) {
            intent.addFlags(1);
        }
        intent.setDataAndType(uri, IConstants.ACCEPT_TYPE_IMAGE);
        intent.putExtra("crop", "true");
        intent.putExtra("aspectX", i);
        intent.putExtra("aspectY", i2);
        intent.putExtra("outputX", i3);
        intent.putExtra("outputY", i4);
        intent.putExtra("scale", true);
        intent.putExtra("circleCrop", false);
        intent.putExtra("output", uri2);
        intent.putExtra("return-data", false);
        intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
        intent.putExtra("noFaceDetection", true);
        fragment.startActivityForResult(intent, i5);
    }
}