package com.ifpdos.factorytest;

import android.content.Context;
import android.graphics.SurfaceTexture;
import android.hardware.camera2.CameraCaptureSession;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraDevice;
import android.hardware.camera2.CameraManager;
import android.hardware.camera2.CaptureRequest;
import android.hardware.camera2.TotalCaptureResult;
import android.hardware.camera2.params.StreamConfigurationMap;
import android.media.Image;
import android.media.ImageReader;
import android.os.Handler;
import android.util.Log;
import android.util.Size;
import android.view.Surface;
import android.widget.Toast;
import com.ifpdos.factorytest.camera.ICameraPictureListener;
import java.io.File;
import java.io.FileOutputStream;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

/* JADX INFO: loaded from: classes.dex */
public class CameraCapture {
    private static final String TAG = "CameraCapturer";
    private CameraCaptureSession mCameraCaptureSession;
    private CameraDevice mCameraDevice;
    private ICameraPictureListener mCameraPictureListener;
    private CaptureRequest.Builder mCaptureRequestBuilder;
    private Context mContext;
    private Handler mHandler;
    private ImageReader mImageReader;
    private Surface mPreviewSurface;
    private int mSensorOrientation;
    private String targetPath;
    private ImageReader.OnImageAvailableListener mOnImageAvailableListener = new ImageReader.OnImageAvailableListener() { // from class: com.ifpdos.factorytest.CameraCapture.1
        @Override // android.media.ImageReader.OnImageAvailableListener
        public void onImageAvailable(ImageReader imageReader) {
            CameraCapture.this.savePhoto(imageReader);
        }
    };
    private CameraDevice.StateCallback mOpenCameraCallback = new CameraDevice.StateCallback() { // from class: com.ifpdos.factorytest.CameraCapture.2
        @Override // android.hardware.camera2.CameraDevice.StateCallback
        public void onDisconnected(CameraDevice cameraDevice) {
        }

        @Override // android.hardware.camera2.CameraDevice.StateCallback
        public void onError(CameraDevice cameraDevice, int i) {
        }

        @Override // android.hardware.camera2.CameraDevice.StateCallback
        public void onOpened(CameraDevice cameraDevice) {
            CameraCapture.this.openCameraSession(cameraDevice);
        }
    };
    private CameraCaptureSession.StateCallback mCreateSessionCallback = new CameraCaptureSession.StateCallback() { // from class: com.ifpdos.factorytest.CameraCapture.3
        @Override // android.hardware.camera2.CameraCaptureSession.StateCallback
        public void onConfigureFailed(CameraCaptureSession cameraCaptureSession) {
        }

        @Override // android.hardware.camera2.CameraCaptureSession.StateCallback
        public void onConfigured(CameraCaptureSession cameraCaptureSession) {
            CameraCapture.this.mCameraCaptureSession = cameraCaptureSession;
            CameraCapture.this.requestPreview();
        }
    };
    private Executor mSavePhotoExecutor = Executors.newSingleThreadExecutor();
    private CameraCaptureSession.CaptureCallback captureCallback = new CameraCaptureSession.CaptureCallback() { // from class: com.ifpdos.factorytest.CameraCapture.4
        @Override // android.hardware.camera2.CameraCaptureSession.CaptureCallback
        public void onCaptureCompleted(CameraCaptureSession cameraCaptureSession, CaptureRequest captureRequest, TotalCaptureResult totalCaptureResult) {
            Log.d(CameraCapture.TAG, "Focus completed");
        }
    };

    public void openCamera(Context context, SurfaceTexture surfaceTexture, String str, int i, int i2, Handler handler) {
        this.mContext = context;
        this.mPreviewSurface = new Surface(surfaceTexture);
        this.mHandler = handler;
        try {
            CameraManager cameraManager = (CameraManager) context.getSystemService("camera");
            CameraCharacteristics cameraCharacteristics = (CameraCharacteristics) CameraManager.class.getMethod("getCameraCharacteristics", String.class).invoke((CameraManager) context.getSystemService("camera"), str);
            Log.d(TAG, "get LENS_FACING: " + cameraCharacteristics.get(CameraCharacteristics.LENS_FACING));
            surfaceTexture.setDefaultBufferSize(3840, 2160);
            this.mImageReader = getImageReader(getMaxSize(((StreamConfigurationMap) cameraCharacteristics.get(CameraCharacteristics.SCALER_STREAM_CONFIGURATION_MAP)).getOutputSizes(ImageReader.class)));
            this.mSensorOrientation = ((Integer) cameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION)).intValue();
            CameraManager.class.getMethod("openCamera", String.class, CameraDevice.StateCallback.class, Handler.class).invoke(cameraManager, str, this.mOpenCameraCallback, this.mHandler);
        } catch (Exception e) {
            Log.e(TAG, "can not open camera", e);
        }
    }

    Size getMaxSize(Size[] sizeArr) {
        Size size = null;
        for (Size size2 : sizeArr) {
            if (size == null || (size2.getWidth() > size.getWidth() && size2.getHeight() > size.getHeight())) {
                size = size2;
            }
        }
        return size;
    }

    public void registerCameraPictureListener(ICameraPictureListener iCameraPictureListener) {
        this.mCameraPictureListener = iCameraPictureListener;
    }

    public void unregisterCameraPictureListener(ICameraPictureListener iCameraPictureListener) {
        this.mCameraPictureListener = null;
    }

    public void closeCamera() {
        ImageReader imageReader = this.mImageReader;
        if (imageReader != null) {
            imageReader.close();
            this.mImageReader = null;
        }
        if (this.mCameraCaptureSession != null) {
            try {
                CameraCaptureSession.class.getMethod("close", new Class[0]).invoke(this.mCameraCaptureSession, new Object[0]);
            } catch (Exception e) {
                Log.e(TAG, "Reflection call failed", e);
            }
            this.mCameraCaptureSession = null;
        }
        if (this.mCameraDevice != null) {
            try {
                CameraDevice.class.getMethod("close", new Class[0]).invoke(this.mCameraDevice, new Object[0]);
            } catch (Exception e2) {
                Log.e(TAG, "Reflection call failed", e2);
            }
            this.mCameraDevice = null;
        }
    }

    private Size getMostSuitableSize(Size[] sizeArr, float f, float f2) {
        float f3 = f2 / f;
        Log.d(TAG, "targetWidth :" + f + ",targetHeight: " + f2 + ",targetRatio: " + f3);
        Size size = null;
        for (Size size2 : sizeArr) {
            Log.d(TAG, "oriSize: " + size2);
            if (size == null || isMoreSuitable(size, size2, f3)) {
                size = size2;
            }
        }
        return size;
    }

    private boolean isMoreSuitable(Size size, Size size2, float f) {
        if (size == null) {
            return true;
        }
        float fAbs = Math.abs(f - getRatio(size2));
        float fAbs2 = Math.abs(f - getRatio(size));
        int area = getArea(size);
        int area2 = getArea(size2);
        Log.d(TAG, "dRatioTarget: " + fAbs + ",dRatioCurrent: " + fAbs2);
        Log.d(TAG, "targetArea: " + area2 + ",currentArea: " + area);
        if (fAbs >= fAbs2) {
            return fAbs == fAbs2 && area2 > area;
        }
        return true;
    }

    private int getArea(Size size) {
        return size.getWidth() * size.getHeight();
    }

    private float getRatio(Size size) {
        return size.getWidth() / size.getHeight();
    }

    private ImageReader getImageReader(Size size) {
        Log.d(TAG, "getImageReader:" + size);
        ImageReader imageReaderNewInstance = ImageReader.newInstance(size.getWidth(), size.getHeight(), 256, 2);
        imageReaderNewInstance.setOnImageAvailableListener(this.mOnImageAvailableListener, this.mHandler);
        return imageReaderNewInstance;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void openCameraSession(CameraDevice cameraDevice) {
        this.mCameraDevice = cameraDevice;
        try {
            CameraDevice.class.getMethod("createCaptureSession", List.class, CameraCaptureSession.StateCallback.class, Handler.class).invoke(this.mCameraDevice, Arrays.asList(this.mPreviewSurface, this.mImageReader.getSurface()), this.mCreateSessionCallback, this.mHandler);
        } catch (Exception e) {
            Log.e(TAG, "createCaptureSession failed", e);
        }
    }

    public void requestPreview() {
        if (this.mCameraDevice == null) {
            return;
        }
        try {
            CaptureRequest.Builder builder = (CaptureRequest.Builder) CameraDevice.class.getMethod("createCaptureRequest", Integer.TYPE).invoke(this.mCameraDevice, 1);
            CaptureRequest.Builder.class.getMethod("addTarget", Surface.class).invoke(builder, this.mPreviewSurface);
            CameraCaptureSession.class.getMethod("setRepeatingRequest", CaptureRequest.class, CameraCaptureSession.CaptureCallback.class, Handler.class).invoke(this.mCameraCaptureSession, builder.build(), null, this.mHandler);
        } catch (Exception e) {
            Log.e(TAG, "Reflection call failed", e);
        }
    }

    public void focusCamera() {
        try {
            CaptureRequest.Builder.class.getMethod("set", CaptureRequest.Key.class, Object.class).invoke(this.mCaptureRequestBuilder, CaptureRequest.CONTROL_AF_TRIGGER, 1);
            CameraCaptureSession.class.getMethod("capture", CaptureRequest.class, CameraCaptureSession.CaptureCallback.class, Handler.class).invoke(this.mCameraCaptureSession, this.mCaptureRequestBuilder.build(), this.captureCallback, this.mHandler);
        } catch (Exception e) {
            Log.e(TAG, "Reflection call failed", e);
        }
    }

    public void takePhoto(String str) {
        try {
            this.targetPath = str;
            CaptureRequest.Builder builder = (CaptureRequest.Builder) CameraDevice.class.getMethod("createCaptureRequest", Integer.TYPE).invoke(this.mCameraDevice, 2);
            Method method = CaptureRequest.Builder.class.getMethod("addTarget", Surface.class);
            method.invoke(builder, this.mPreviewSurface);
            method.invoke(builder, this.mImageReader.getSurface());
            CaptureRequest.Builder.class.getMethod("set", CaptureRequest.Key.class, Object.class).invoke(builder, CaptureRequest.JPEG_ORIENTATION, Integer.valueOf(this.mSensorOrientation));
            CameraCaptureSession.class.getMethod("stopRepeating", new Class[0]).invoke(this.mCameraCaptureSession, new Object[0]);
            CameraCaptureSession.class.getMethod("capture", CaptureRequest.class, CameraCaptureSession.CaptureCallback.class, Handler.class).invoke(this.mCameraCaptureSession, builder.build(), null, null);
        } catch (Exception e) {
            Log.e(TAG, "Reflection call failed", e);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void savePhoto(ImageReader imageReader) {
        final Image imageAcquireLatestImage = imageReader.acquireLatestImage();
        if (imageAcquireLatestImage == null) {
            return;
        }
        final String str = "IMG_" + System.currentTimeMillis() + ".jpeg";
        Toast.makeText(this.mContext, str, 0).show();
        this.mSavePhotoExecutor.execute(new Runnable() { // from class: com.ifpdos.factorytest.CameraCapture$$ExternalSyntheticLambda0
            @Override // java.lang.Runnable
            public final void run() {
                this.f$0.lambda$savePhoto$0(str, imageAcquireLatestImage);
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public /* synthetic */ void lambda$savePhoto$0(String str, Image image) {
        String str2 = this.targetPath;
        if (str2 == null || str2.isEmpty()) {
            str2 = "/sdcard/" + str;
            Log.d(TAG, "targetPath null,set default path" + str2);
        }
        try {
            FileOutputStream fileOutputStream = new FileOutputStream(new File(str2));
            try {
                ByteBuffer buffer = image.getPlanes()[0].getBuffer();
                byte[] bArr = new byte[buffer.remaining()];
                buffer.get(bArr);
                fileOutputStream.write(bArr);
                this.mCameraPictureListener.takePictureFinish(str2);
                fileOutputStream.close();
            } finally {
            }
        } catch (Exception e) {
            Log.d(TAG, "save photo failed", e);
            this.mCameraPictureListener.takePictureFinish("");
        }
        this.targetPath = "";
        image.close();
    }
}