Cashalo v2.25.0.0 - SelfieV2PortraitActivity.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.view.View;
import android.widget.ImageView;
import android.widget.LinearLayout;
import androidx.camera.core.Camera;
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.core.debug.log.Logger;
import com.oriente.core.internal.ScreenName;
import com.oriente.core.page.PageManager;
import com.oriente.core.page.PageTarget;
import com.oriente.core.page.jump.Jumper;
import com.oriente.core.task.Worker;
import com.oriente.http.image.ImageDisplay;
import com.oriente.uikit.utils.ViewUtils;
import com.oriente.utils.ImageUtils;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
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("Upload a Selfie while holding ID")
public class SelfieV2PortraitActivity extends BaseActivity {
    private static final float RATIO_16_9_VALUE = 1.7777778f;
    private static final float RATIO_4_3_VALUE = 1.3333334f;
    ImageView mCaptureImage;
    private Uri mCaptureUri;
    private ExecutorService mExecutor = Executors.newSingleThreadExecutor();
    LinearLayout mHandleImgLayout;
    private String mOriginUrl;
    PreviewView mPreviewView;
    SimpleDraweeView mSimpleDraweeView;

    @Override
    protected void onCreate(Bundle bundle) {
        requestWindowFeature(1);
        super.onCreate(bundle);
        setContentView(R.layout.fragment_selfie_v2);
        initView();
        startCamera();
    }

    private void initView() {
        this.mPreviewView = findViewById(R.id.previewView);
        this.mCaptureImage = (ImageView) findViewById(R.id.captureImg);
        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) {
                SelfieV2PortraitActivity.this.lambda$initView$0(view);
            }
        });
        findViewById(R.id.okBtn).setOnClickListener(new View.OnClickListener() {
            @Override
            public final void onClick(View view) {
                SelfieV2PortraitActivity.this.lambda$initView$1(view);
            }
        });
        findViewById(R.id.back).setOnClickListener(new View.OnClickListener() {
            @Override
            public final void onClick(View view) {
                SelfieV2PortraitActivity.this.lambda$initView$2(view);
            }
        });
    }

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

    public void lambda$initView$1(View view) {
        Uri uri = this.mCaptureUri;
        if (uri != null) {
            compressImage(this, uri);
        }
    }

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

    public void compressImage(PageTarget pageTarget, Uri uri) {
        if (pageTarget == null || uri == null) {
            return;
        }
        EventBus.getDefault().post(new LoadingEvent(true));
        File uri2File = ImageUtils.INSTANCE.uri2File(pageTarget.getContext(), uri);
        if (!uri2File.exists()) {
            EventBus.getDefault().post(new LoadingEvent(false));
            CommonAnalytics.analyticsImportantStep(CommonAnalytics.toProperties("upload_path_to_h5_null", "true", new Object[0]));
        } else {
            Luban.with(pageTarget.getContext()).setTargetDir(ValueConfig.getCompressImageCache()).load(uri2File).setCompressListener(new OnCompressListener() {
                public void onStart() {
                }

                public void onSuccess(File file) {
                    EventBus.getDefault().post(new LoadingEvent(false));
                    SelfieV2PortraitActivity.this.uploadCapture(file.getAbsolutePath());
                }

                public void onError(Throwable th) {
                    EventBus.getDefault().post(new LoadingEvent(false));
                    Logger.error(th);
                }
            }).launch();
        }
    }

    public void uploadCapture(String str) {
        Intent intent = new Intent();
        intent.putExtras(Jumper.obtain(new Object[]{"imageData", str}));
        setResult(-1, intent);
        finish();
    }

    private void reTakePicture() {
        ViewUtils.setVisibility(this.mPreviewView, 0);
        ViewUtils.setVisibility(this.mCaptureImage, 0);
        ViewUtils.setVisibility(this.mSimpleDraweeView, 8);
        ViewUtils.setVisibility(this.mHandleImgLayout, 8);
    }

    public void showPreViewCaptureImage() {
        ViewUtils.setVisibility(this.mPreviewView, 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 {
                    SelfieV2PortraitActivity.this.bindPreview((ProcessCameraProvider) processCameraProvider.get());
                } catch (InterruptedException | ExecutionException unused) {
                }
            }
        }, ContextCompat.getMainExecutor(this));
    }

    void bindPreview(final ProcessCameraProvider processCameraProvider) {
        final Preview build = new Preview.Builder().build();
        final CameraSelector build2 = new CameraSelector.Builder().requireLensFacing(1).build();
        final ImageCapture.Builder builder = new ImageCapture.Builder();
        this.mPreviewView.post(new Runnable() {
            @Override
            public final void run() {
                SelfieV2PortraitActivity.this.lambda$bindPreview$4(builder, build, processCameraProvider, build2);
            }
        });
    }

    public void lambda$bindPreview$4(ImageCapture.Builder builder, Preview preview, ProcessCameraProvider processCameraProvider, CameraSelector cameraSelector) {
        final ImageCapture build = builder.setTargetRotation(getWindowManager().getDefaultDisplay().getRotation()).setTargetAspectRatio(aspectRatio(this.mPreviewView.getWidth(), this.mPreviewView.getHeight())).build();
        preview.setSurfaceProvider(this.mPreviewView.getSurfaceProvider());
        try {
            Camera bindToLifecycle = processCameraProvider.bindToLifecycle(this, cameraSelector, new UseCase[]{preview, build});
            this.mCaptureImage.setOnClickListener(new View.OnClickListener() {
                @Override
                public final void onClick(View view) {
                    SelfieV2PortraitActivity.this.lambda$bindPreview$3(build, view);
                }
            });
            autoFocusAfterMeasure(bindToLifecycle);
        } catch (IllegalArgumentException e) {
            Logger.error(e);
        }
    }

    public void lambda$bindPreview$3(ImageCapture imageCapture, View view) {
        File file = new File(PageManager.getApplicationContext().getCacheDir().getAbsolutePath() + File.separator + "profile");
        checkFileExist(file);
        final File file2 = new File(file, System.currentTimeMillis() + ".jpg");
        imageCapture.takePicture(new ImageCapture.OutputFileOptions.Builder(file2).build(), this.mExecutor, new ImageCapture.OnImageSavedCallback() {
            public void onImageSaved(ImageCapture.OutputFileResults outputFileResults) {
                SelfieV2PortraitActivity.this.mCaptureUri = outputFileResults.getSavedUri() != null ? outputFileResults.getSavedUri() : Uri.fromFile(file2);
                ImageUtils imageUtils = ImageUtils.INSTANCE;
                ?? r0 = SelfieV2PortraitActivity.this;
                final File uri2File = imageUtils.uri2File((Context) r0, ((SelfieV2PortraitActivity) r0).mCaptureUri);
                SelfieV2PortraitActivity.this.mOriginUrl = uri2File.getAbsolutePath();
                try {
                    Bitmap decodeFile = BitmapFactory.decodeFile(SelfieV2PortraitActivity.this.mOriginUrl);
                    ?? r1 = SelfieV2PortraitActivity.this;
                    Bitmap rotateImageIfRequired = SelfieV2PortraitActivity.rotateImageIfRequired(r1, decodeFile, ((SelfieV2PortraitActivity) r1).mCaptureUri);
                    FileOutputStream fileOutputStream = new FileOutputStream(SelfieV2PortraitActivity.this.mOriginUrl);
                    if (rotateImageIfRequired != null) {
                        rotateImageIfRequired.compress(Bitmap.CompressFormat.JPEG, 100, fileOutputStream);
                    }
                    fileOutputStream.flush();
                    fileOutputStream.close();
                    if (rotateImageIfRequired != null) {
                        FS.bitmap_recycle(rotateImageIfRequired);
                    }
                    if (decodeFile != null) {
                        FS.bitmap_recycle(decodeFile);
                    }
                    if (uri2File != null) {
                        Worker.runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                SelfieV2PortraitActivity.this.showPreViewCaptureImage();
                                ImageDisplay.with(SelfieV2PortraitActivity.this.mSimpleDraweeView).scaleType(ScalingUtils.ScaleType.FIT_XY).display(Uri.fromFile(uri2File));
                            }
                        }, 16L);
                    }
                } catch (IOException e) {
                    CommonAnalytics.analyticsImportantStep(CommonAnalytics.toProperties(" selfie rotate image", true, new Object[0]));
                    throw new RuntimeException(e);
                }
            }

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

    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) {
        Matrix matrix = new Matrix();
        matrix.postRotate(f);
        return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
    }

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

    private int aspectRatio(int i, int i2) {
        float f = i;
        Float.valueOf(f).getClass();
        float f2 = 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);
        return Math.abs(min - RATIO_4_3_VALUE) <= Math.abs(min - RATIO_16_9_VALUE) ? 0 : 1;
    }

    private 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();
        }
    }
}