Cashalo v2.25.0.0 - IdPhotoPortraitActivity.java 源代码

package com.oriente.cashalo.page.activity;

import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.text.TextUtils;
import android.view.View;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.TextView;
import androidx.activity.result.ActivityResultCallback;
import androidx.activity.result.ActivityResultLauncher;
import androidx.activity.result.PickVisualMediaRequest;
import androidx.activity.result.contract.ActivityResultContracts;
import androidx.camera.core.Camera;
import androidx.camera.core.CameraInfoUnavailableException;
import androidx.camera.core.CameraSelector;
import androidx.camera.core.FocusMeteringAction;
import androidx.camera.core.ImageCapture;
import androidx.camera.core.ImageCaptureException;
import androidx.camera.core.Preview;
import androidx.camera.core.SurfaceOrientedMeteringPointFactory;
import androidx.camera.core.UseCase;
import androidx.camera.lifecycle.ProcessCameraProvider;
import androidx.camera.view.PreviewView;
import androidx.core.content.ContextCompat;
import com.facebook.drawee.drawable.ScalingUtils;
import com.facebook.drawee.view.SimpleDraweeView;
import com.fullstory.FS;
import com.google.common.util.concurrent.ListenableFuture;
import com.oriente.adapter.R;
import com.oriente.adapter.analytics.impl.CommonAnalytics;
import com.oriente.adapter.config.ValueConfig;
import com.oriente.adapter.page.BaseActivity;
import com.oriente.adapter.page.BaseActivity$$ExternalSyntheticApiModelOutline0;
import com.oriente.adapter.page.LoadingEvent;
import com.oriente.cashalo.page.activity.IdPhotoPortraitActivity;
import com.oriente.cashalo.service.model.common.OcrResult;
import com.oriente.cashalo.service.model.config.ConfigSwitchType;
import com.oriente.cashalo.utils.EnhanceImageManager;
import com.oriente.cashalo.widget.MaskView;
import com.oriente.core.internal.ScreenName;
import com.oriente.core.page.PageManager;
import com.oriente.core.page.jump.Jumper;
import com.oriente.core.router.Router;
import com.oriente.core.router.RouterScene;
import com.oriente.core.task.Worker;
import com.oriente.core.utils.ResUtils;
import com.oriente.core.utils.StringUtils;
import com.oriente.core.utils.ToastUtils;
import com.oriente.http.image.ImageDisplay;
import com.oriente.manager.OrientManager;
import com.oriente.plugin.PluginResult;
import com.oriente.plugin.PluginResultCallback;
import com.oriente.plugin.module.AppPlugin;
import com.oriente.plugin.module.VerifyPlugin;
import com.oriente.uikit.utils.ViewUtils;
import com.oriente.uimodule.alert.Alert;
import com.oriente.uimodule.alert.AlertBuilder;
import com.oriente.utils.ImageUtils;
import com.oriente.utils.PathUtil;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.Serializable;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.greenrobot.eventbus.EventBus;
import top.zibin.luban.Luban;
import top.zibin.luban.OnCompressListener;

@ScreenName("Take ID Photo")
public class IdPhotoPortraitActivity extends BaseActivity {
    public static final String BACK = "back";
    public static final String FRONT = "front";
    private static final float RATIO_16_9_VALUE = 1.7777778f;
    private static final float RATIO_4_3_VALUE = 1.3333334f;
    ProcessCameraProvider cameraProvider;
    private ExecutorService executorService;
    ImageView mCaptureImage;
    private File mCropCompressedFile;
    private String mCropImageUrl;
    LinearLayout mHandleImgLayout;
    private MaskView mMaskView;
    private File mOriginCompressedFile;
    private String mOriginUrl;
    PreviewView mPreviewView;
    SimpleDraweeView mSimpleDraweeView;
    private TextView mTvTips;
    private ActivityResultLauncher<PickVisualMediaRequest> pickMedia;
    private ExecutorService mExecutor = Executors.newSingleThreadExecutor();
    private CountDownLatch mLatch = new CountDownLatch(2);
    public String frontOrBack = null;

    @Override
    protected void onCreate(Bundle bundle) {
        requestWindowFeature(1);
        super.onCreate(bundle);
        setContentView(R.layout.fragment_id_photo);
        if (OrientManager.getPlugin(AppPlugin.class).isExtraSwitchOn(this, String.valueOf(ConfigSwitchType.SWITCH_GET_PICTURE_FROM_ALBUM.type))) {
            this.pickMedia = registerForActivityResult(new ActivityResultContracts.PickVisualMedia(), new ActivityResultCallback() {
                public final void onActivityResult(Object obj) {
                    IdPhotoPortraitActivity.this.lambda$onCreate$0((Uri) obj);
                }
            });
        }
        if (getIntent() != null && getIntent().getStringExtra("frontOrBack") != null) {
            this.frontOrBack = getIntent().getStringExtra("frontOrBack");
        }
        initView();
        startCamera();
        this.executorService = Executors.newFixedThreadPool(2);
    }

    public void lambda$onCreate$0(Uri uri) {
        if (uri != null) {
            showImageFromAlbum(uri);
        }
    }

    private void initView() {
        TextView textView = (TextView) findViewById(R.id.titleTv);
        if (TextUtils.equals(this.frontOrBack, "front")) {
            textView.setText("Take ID Photo - Photo Page");
        } else if (TextUtils.equals(this.frontOrBack, "back")) {
            textView.setText("Take ID Photo - Back of ID Card");
        }
        this.mPreviewView = findViewById(R.id.previewView);
        this.mCaptureImage = (ImageView) findViewById(R.id.captureImg);
        this.mMaskView = findViewById(R.id.maskView);
        this.mTvTips = (TextView) findViewById(R.id.tvTips);
        this.mSimpleDraweeView = findViewById(R.id.simpleDraweeView);
        this.mHandleImgLayout = (LinearLayout) findViewById(R.id.handleImgLayout);
        findViewById(R.id.reTakeBtn).setOnClickListener(new View.OnClickListener() {
            @Override
            public final void onClick(View view) {
                IdPhotoPortraitActivity.this.lambda$initView$1(view);
            }
        });
        findViewById(R.id.okBtn).setOnClickListener(new View.OnClickListener() {
            @Override
            public final void onClick(View view) {
                IdPhotoPortraitActivity.this.lambda$initView$2(view);
            }
        });
        findViewById(R.id.back).setOnClickListener(new View.OnClickListener() {
            @Override
            public final void onClick(View view) {
                IdPhotoPortraitActivity.this.lambda$initView$3(view);
            }
        });
        AppPlugin plugin = OrientManager.getPlugin(AppPlugin.class);
        TextView textView2 = (TextView) findViewById(R.id.tvFromAlbum);
        if (plugin.isExtraSwitchOn(this, String.valueOf(ConfigSwitchType.SWITCH_GET_PICTURE_FROM_ALBUM.type))) {
            textView2.setVisibility(0);
            findViewById(R.id.tvFromAlbum).setOnClickListener(new View.OnClickListener() {
                @Override
                public final void onClick(View view) {
                    IdPhotoPortraitActivity.this.lambda$initView$4(view);
                }
            });
        } else {
            textView2.setVisibility(8);
            findViewById(R.id.tvFromAlbum).setOnClickListener(null);
        }
        findViewById(R.id.info).setOnClickListener(new View.OnClickListener() {
            @Override
            public final void onClick(View view) {
                IdPhotoPortraitActivity.this.lambda$initView$5(view);
            }
        });
    }

    public void lambda$initView$1(View view) {
        reTakePicture();
    }

    public void lambda$initView$2(View view) {
        if (this.mOriginUrl != null) {
            checkImageRuleWithImageUrl();
        }
    }

    public void lambda$initView$3(View view) {
        finish();
    }

    public void lambda$initView$4(View view) {
        CommonAnalytics.analyticsImportantStep(CommonAnalytics.toProperties("Take ID Photo", "photopicker", new Object[0]));
        this.pickMedia.launch(new PickVisualMediaRequest.Builder().setMediaType(ActivityResultContracts.PickVisualMedia.ImageOnly.INSTANCE).build());
    }

    public void lambda$initView$5(View view) {
        Router.from(this).deliver(ValueConfig.URL_DOMAIN_MPF + "profile/id-example", RouterScene.INNER);
    }

    private void checkImageRuleWithImageUrl() {
        final VerifyPlugin plugin = OrientManager.getPlugin(VerifyPlugin.class);
        plugin.checkImageRuleWithImageUrl(this, Jumper.obtain(new Object[]{"originUrl", this.mOriginUrl}), new PluginResultCallback() {
            public final void onPluginResult(PluginResult pluginResult) {
                IdPhotoPortraitActivity.this.lambda$checkImageRuleWithImageUrl$7(plugin, pluginResult);
            }
        });
    }

    public void lambda$checkImageRuleWithImageUrl$7(VerifyPlugin verifyPlugin, PluginResult pluginResult) {
        if (pluginResult.isSuccess()) {
            verifyPlugin.checkReflectiveAndBlur(this, Jumper.obtain(new Object[]{"enhanceUrl", this.mCropImageUrl}), new PluginResultCallback() {
                public final void onPluginResult(PluginResult pluginResult2) {
                    IdPhotoPortraitActivity.this.lambda$checkImageRuleWithImageUrl$6(pluginResult2);
                }
            });
        } else {
            Alert.from(this).message(String.format(ResUtils.string(R.string.ori_component_alert_check_image_valid), "ID")).button(ResUtils.string(R.string.ori_common_btn_ok)).callback(new Alert.IAlertAction() {
                public void onAlertAction(AlertBuilder alertBuilder, int i) {
                    if (i == 2) {
                        IdPhotoPortraitActivity.this.reTakePicture();
                    }
                }
            }).show();
        }
    }

    public void lambda$checkImageRuleWithImageUrl$6(PluginResult pluginResult) {
        if (pluginResult.isSuccess()) {
            Serializable serializable = pluginResult.getResult().getSerializable("data");
            if (serializable == null || !(serializable instanceof OcrResult)) {
                return;
            }
            OcrResult ocrResult = (OcrResult) serializable;
            if (ocrResult.resultType == 1) {
                reTakePicture();
                return;
            } else if (ocrResult.file != null && StringUtils.isVisibleUnNull(ocrResult.file.getAbsolutePath())) {
                executeCompressImageTasks(this.mOriginUrl, ocrResult.file.getAbsolutePath(), ocrResult);
                return;
            } else {
                executeCompressImageTasks(this.mOriginUrl, this.mCropImageUrl, ocrResult);
                return;
            }
        }
        executeCompressImageTasks(this.mOriginUrl, this.mCropImageUrl, null);
    }

    public void reTakePicture() {
        this.mTvTips.setText(ResUtils.string(R.string.ori_upload_tips_take_id_photo));
        ViewUtils.setVisibility(this.mPreviewView, 0);
        ViewUtils.setVisibility(this.mMaskView, 0);
        ViewUtils.setVisibility(this.mCaptureImage, 0);
        ViewUtils.setVisibility(this.mSimpleDraweeView, 8);
        ViewUtils.setVisibility(this.mHandleImgLayout, 8);
    }

    private void showPreViewCaptureImage() {
        this.mTvTips.setText(ResUtils.string(R.string.ori_upload_tips2_take_id_photo));
        ViewUtils.setVisibility(this.mPreviewView, 8);
        ViewUtils.setVisibility(this.mMaskView, 8);
        ViewUtils.setVisibility(this.mCaptureImage, 8);
        ViewUtils.setVisibility(this.mSimpleDraweeView, 0);
        ViewUtils.setVisibility(this.mHandleImgLayout, 0);
    }

    private void startCamera() {
        final ListenableFuture processCameraProvider = ProcessCameraProvider.getInstance(this);
        processCameraProvider.addListener(new Runnable() {
            @Override
            public void run() {
                try {
                    IdPhotoPortraitActivity.this.cameraProvider = (ProcessCameraProvider) processCameraProvider.get();
                    IdPhotoPortraitActivity.this.bindPreview();
                } catch (InterruptedException | ExecutionException unused) {
                }
            }
        }, ContextCompat.getMainExecutor(this));
    }

    void bindPreview() {
        Preview build = new Preview.Builder().build();
        this.mPreviewView.post(new AnonymousClass3(new ImageCapture.Builder(), build));
    }

    class AnonymousClass3 implements Runnable {
        final ImageCapture.Builder val$imageCaptureBuilder;
        final Preview val$preview;

        AnonymousClass3(ImageCapture.Builder builder, Preview preview) {
            this.val$imageCaptureBuilder = builder;
            this.val$preview = preview;
        }

        @Override
        public void run() {
            ImageCapture.Builder targetRotation = this.val$imageCaptureBuilder.setTargetRotation(IdPhotoPortraitActivity.this.getWindowManager().getDefaultDisplay().getRotation());
            IdPhotoPortraitActivity idPhotoPortraitActivity = IdPhotoPortraitActivity.this;
            final UseCase build = targetRotation.setTargetAspectRatio(idPhotoPortraitActivity.aspectRatio(idPhotoPortraitActivity.mPreviewView.getWidth(), IdPhotoPortraitActivity.this.mPreviewView.getHeight())).build();
            this.val$preview.setSurfaceProvider(IdPhotoPortraitActivity.this.mPreviewView.getSurfaceProvider());
            try {
                if (IdPhotoPortraitActivity.this.cameraProvider.hasCamera(CameraSelector.DEFAULT_BACK_CAMERA)) {
                    CameraSelector build2 = new CameraSelector.Builder().requireLensFacing(1).build();
                    if (IdPhotoPortraitActivity.this.isDestroyed() || IdPhotoPortraitActivity.this.isFinishing()) {
                        return;
                    }
                    Camera bindToLifecycle = IdPhotoPortraitActivity.this.cameraProvider.bindToLifecycle(IdPhotoPortraitActivity.this, build2, new UseCase[]{this.val$preview, build});
                    IdPhotoPortraitActivity.this.mCaptureImage.setOnClickListener(new View.OnClickListener() {
                        @Override
                        public final void onClick(View view) {
                            IdPhotoPortraitActivity.AnonymousClass3.this.lambda$run$0(build, view);
                        }
                    });
                    IdPhotoPortraitActivity.this.autoFocusAfterMeasure(bindToLifecycle);
                    return;
                }
                ToastUtils.pop("The rear camera is temporarily unavailable, please try again later.");
            } catch (CameraInfoUnavailableException e) {
                throw new RuntimeException((Throwable) e);
            }
        }

        public void lambda$run$0(ImageCapture imageCapture, View view) {
            File file = new File(PageManager.getApplicationContext().getCacheDir().getAbsolutePath() + File.separator + "profile");
            IdPhotoPortraitActivity.this.checkFileExist(file);
            final File file2 = new File(file, System.currentTimeMillis() + ".jpg");
            imageCapture.takePicture(new ImageCapture.OutputFileOptions.Builder(file2).build(), IdPhotoPortraitActivity.this.mExecutor, new ImageCapture.OnImageSavedCallback() {
                public void onImageSaved(ImageCapture.OutputFileResults outputFileResults) {
                    AnonymousClass3.this.onImageSavedImpl(outputFileResults, file2);
                }

                public void onError(ImageCaptureException imageCaptureException) {
                    imageCaptureException.printStackTrace();
                }
            });
        }

        public void onImageSavedImpl(final ImageCapture.OutputFileResults outputFileResults, final File file) {
            EventBus.getDefault().post(new LoadingEvent(true));
            Worker.queue(new Runnable() {
                @Override
                public final void run() {
                    IdPhotoPortraitActivity.AnonymousClass3.this.lambda$onImageSavedImpl$1(outputFileResults, file);
                }
            }, 16L);
        }

        public void lambda$onImageSavedImpl$1(ImageCapture.OutputFileResults outputFileResults, File file) {
            Uri savedUri = outputFileResults.getSavedUri() != null ? outputFileResults.getSavedUri() : Uri.fromFile(file);
            File uri2File = ImageUtils.INSTANCE.uri2File(IdPhotoPortraitActivity.this, savedUri);
            File file2 = new File(PathUtil.getCacheDirectory(IdPhotoPortraitActivity.this), System.currentTimeMillis() + ".jpg");
            IdPhotoPortraitActivity.this.mOriginUrl = uri2File.getAbsolutePath();
            try {
                try {
                    Bitmap decodeFile = BitmapFactory.decodeFile(IdPhotoPortraitActivity.this.mOriginUrl);
                    Bitmap rotateImageIfRequired = IdPhotoPortraitActivity.rotateImageIfRequired(IdPhotoPortraitActivity.this, decodeFile, savedUri);
                    Bitmap cropBitmapByMaskView = IdPhotoPortraitActivity.this.getCropBitmapByMaskView(file2, rotateImageIfRequired);
                    if (rotateImageIfRequired != null) {
                        FS.bitmap_recycle(rotateImageIfRequired);
                    }
                    if (decodeFile != null) {
                        FS.bitmap_recycle(decodeFile);
                    }
                    if (cropBitmapByMaskView != null) {
                        FS.bitmap_recycle(cropBitmapByMaskView);
                    }
                    IdPhotoPortraitActivity.this.mCropImageUrl = file2.getAbsolutePath();
                } catch (IOException e) {
                    CommonAnalytics.analyticsImportantStep(CommonAnalytics.toProperties("idPhoto rotate image", true, new Object[0]));
                    throw new RuntimeException(e);
                }
            } finally {
                IdPhotoPortraitActivity.this.showCropImage(file2);
            }
        }
    }

    public Bitmap getCropBitmapByMaskView(File file, Bitmap bitmap) throws IOException {
        float width = (bitmap.getWidth() * 0.14f) - ResUtils.dip2px(40.0f);
        float height = (((this.mMaskView.getHeight() - ResUtils.dip2px(208.0f)) / 2.0f) / this.mMaskView.getHeight()) * bitmap.getHeight();
        int width2 = ((int) (bitmap.getWidth() * 0.86f)) - ResUtils.dip2px(76.0f);
        int dip2px = (int) ((ResUtils.dip2px(208.0f) / (this.mMaskView.getHeight() * 1.0f)) * bitmap.getHeight());
        try {
            if (width2 + width > bitmap.getWidth() || dip2px + height > bitmap.getHeight()) {
                CommonAnalytics.analyticsClick(getPageId(), "Crop area exceeds the boundaries");
                throw new IllegalArgumentException("Crop area exceeds the boundaries of the original bitmap.");
            }
            Bitmap createBitmap = Bitmap.createBitmap(bitmap, (int) width, (int) height, width2, dip2px);
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            try {
                if (createBitmap.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream)) {
                    fileOutputStream.flush();
                }
                fileOutputStream.close();
                FS.bitmap_recycle(createBitmap);
                return createBitmap;
            } catch (Throwable th) {
                fileOutputStream.close();
                throw th;
            }
        } catch (IllegalArgumentException | OutOfMemoryError unused) {
            return null;
        }
    }

    public static Bitmap rotateImageIfRequired(Context context, Bitmap bitmap, Uri uri) throws IOException {
        int attributeInt = (Build.VERSION.SDK_INT > 23 ? BaseActivity$$ExternalSyntheticApiModelOutline0.m(context.getContentResolver().openInputStream(uri)) : new ExifInterface(uri.getPath())).getAttributeInt("Orientation", 1);
        if (attributeInt == 3) {
            return rotateImage(bitmap, 180.0f);
        }
        if (attributeInt != 6) {
            return attributeInt != 8 ? bitmap : rotateImage(bitmap, 270.0f);
        }
        return rotateImage(bitmap, 90.0f);
    }

    public static Bitmap rotateImage(Bitmap bitmap, float f) {
        int width = bitmap.getWidth() / 2;
        int height = bitmap.getHeight() / 2;
        Bitmap createScaledBitmap = Bitmap.createScaledBitmap(bitmap, width, height, true);
        Matrix matrix = new Matrix();
        matrix.postRotate(f);
        try {
            Bitmap createBitmap = Bitmap.createBitmap(createScaledBitmap, 0, 0, width, height, matrix, true);
            FS.bitmap_recycle(createScaledBitmap);
            return createBitmap;
        } catch (OutOfMemoryError e) {
            e.printStackTrace();
            return null;
        }
    }

    public void executeCompressImageTasks(final String str, final String str2, final OcrResult ocrResult) {
        if (StringUtils.isVisible(str2)) {
            this.mLatch = new CountDownLatch(2);
        } else {
            this.mLatch = new CountDownLatch(1);
        }
        EventBus.getDefault().post(new LoadingEvent(true));
        final ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(2);
        Callable callable = new Callable() {
            @Override
            public final Object call() {
                File lambda$executeCompressImageTasks$8;
                lambda$executeCompressImageTasks$8 = IdPhotoPortraitActivity.this.lambda$executeCompressImageTasks$8(str);
                return lambda$executeCompressImageTasks$8;
            }
        };
        Callable callable2 = StringUtils.isVisible(str2) ? new Callable() {
            @Override
            public final Object call() {
                File lambda$executeCompressImageTasks$9;
                lambda$executeCompressImageTasks$9 = IdPhotoPortraitActivity.this.lambda$executeCompressImageTasks$9(str2);
                return lambda$executeCompressImageTasks$9;
            }
        } : null;
        newFixedThreadPool.submit(callable);
        if (StringUtils.isVisible(str2) && callable2 != null) {
            newFixedThreadPool.submit(callable2);
        }
        newFixedThreadPool.submit(new Runnable() {
            @Override
            public final void run() {
                IdPhotoPortraitActivity.this.lambda$executeCompressImageTasks$10(ocrResult, newFixedThreadPool);
            }
        });
    }

    public File lambda$executeCompressImageTasks$8(String str) throws Exception {
        Luban.with(this).setTargetDir(ValueConfig.getCompressImageCache()).load(str).setCompressListener(new OnCompressListener() {
            public void onStart() {
            }

            public void onSuccess(File file) {
                IdPhotoPortraitActivity.this.mOriginCompressedFile = file;
                IdPhotoPortraitActivity.this.mLatch.countDown();
            }

            public void onError(Throwable th) {
                IdPhotoPortraitActivity.this.mLatch.countDown();
            }
        }).launch();
        this.mLatch.await();
        return this.mOriginCompressedFile;
    }

    public File lambda$executeCompressImageTasks$9(String str) throws Exception {
        Luban.with(this).setTargetDir(ValueConfig.getCompressImageCache()).load(str).setCompressListener(new OnCompressListener() {
            public void onStart() {
            }

            public void onSuccess(File file) {
                IdPhotoPortraitActivity.this.mCropCompressedFile = file;
                IdPhotoPortraitActivity.this.mLatch.countDown();
            }

            public void onError(Throwable th) {
                IdPhotoPortraitActivity.this.mLatch.countDown();
            }
        }).launch();
        this.mLatch.await();
        return this.mCropCompressedFile;
    }

    public void lambda$executeCompressImageTasks$10(OcrResult ocrResult, ExecutorService executorService) {
        try {
            try {
                this.mLatch.await();
                afterBothTasksFinishedCallbackToH5(this.mOriginCompressedFile, this.mCropCompressedFile, ocrResult);
            } catch (InterruptedException unused) {
                Thread.currentThread().interrupt();
            }
        } finally {
            executorService.shutdown();
        }
    }

    private void afterBothTasksFinishedCallbackToH5(File file, File file2, OcrResult ocrResult) {
        String absolutePath = file.getAbsolutePath();
        String absolutePath2 = file2 == null ? absolutePath : file2.getAbsolutePath();
        EventBus.getDefault().post(new LoadingEvent(false));
        Intent intent = new Intent();
        Bundle obtain = Jumper.obtain(new Object[]{"imageData", absolutePath2, "originImageData", absolutePath});
        if (ocrResult != null) {
            obtain.putSerializable("ocrResult", ocrResult);
        }
        intent.putExtras(obtain);
        setResult(-1, intent);
        finish();
    }

    public void showCropImage(final File file) {
        Worker.runOnUiThread(new Runnable() {
            @Override
            public final void run() {
                IdPhotoPortraitActivity.this.lambda$showCropImage$11(file);
            }
        }, 16L);
    }

    public void lambda$showCropImage$11(File file) {
        EventBus.getDefault().post(new LoadingEvent(false));
        ImageDisplay.with(this.mSimpleDraweeView).scaleType(ScalingUtils.ScaleType.FIT_CENTER).display(Uri.fromFile(file));
        showPreViewCaptureImage();
        FS.log_d(EnhanceImageManager.TAG, "mMaskView.getFrameRect().left =" + this.mMaskView.getFrameRect().left + "     mMaskView.getFrameRect().top =" + this.mMaskView.getFrameRect().top + "   mMaskView.getFrameRect().right =" + this.mMaskView.getFrameRect().right + "mMaskView.getFrameRect().top =" + this.mMaskView.getFrameRect().bottom);
    }

    public void checkFileExist(File file) {
        if (file == null || file.exists()) {
            return;
        }
        file.mkdirs();
    }

    public int aspectRatio(int i, int i2) {
        FS.log_d(EnhanceImageManager.TAG, "width =" + i + "   height=" + i2);
        float f = (float) i;
        Float.valueOf(f).getClass();
        float f2 = (float) i2;
        Float.valueOf(f2).getClass();
        float max = Math.max(f, f2);
        Float.valueOf(f).getClass();
        Float.valueOf(f2).getClass();
        float min = max / Math.min(f, f2);
        FS.log_d(EnhanceImageManager.TAG, "width =" + i + "   height=" + i2 + "   previewRatio =" + min);
        return Math.abs(min - RATIO_4_3_VALUE) <= Math.abs(min - RATIO_16_9_VALUE) ? 0 : 1;
    }

    public void autoFocusAfterMeasure(Camera camera) {
        FocusMeteringAction.Builder builder = new FocusMeteringAction.Builder(new SurfaceOrientedMeteringPointFactory(this.mPreviewView.getWidth(), this.mPreviewView.getHeight()).createPoint(this.mPreviewView.getWidth() / 2, this.mPreviewView.getHeight() / 2), 1);
        builder.setAutoCancelDuration(1L, TimeUnit.SECONDS);
        if (camera != null) {
            camera.getCameraControl().startFocusAndMetering(builder.build());
        }
    }

    protected void onDestroy() {
        super.onDestroy();
        ExecutorService executorService = this.mExecutor;
        if (executorService != null) {
            executorService.shutdown();
        }
        ProcessCameraProvider processCameraProvider = this.cameraProvider;
        if (processCameraProvider != null) {
            processCameraProvider.unbindAll();
        }
    }

    protected void onActivityResult(int i, int i2, Intent intent) {
        super.onActivityResult(i, i2, intent);
        if (i2 == -1 && i == 19 && intent.getData() != null) {
            EventBus.getDefault().post(new LoadingEvent(true));
            showImageFromAlbum(intent.getData());
            getContentResolver().takePersistableUriPermission(intent.getData(), 1);
        }
    }

    private void showImageFromAlbum(Uri uri) {
        File uri2File = ImageUtils.INSTANCE.uri2File(this, uri);
        this.mOriginUrl = uri2File.getAbsolutePath();
        if (uri2File != null) {
            showCropImage(uri2File);
        }
    }
}