1145 lines
50 KiB
Java
1145 lines
50 KiB
Java
package io.flutter.plugins.camera;
|
|
|
|
import android.app.Activity;
|
|
import android.content.Context;
|
|
import android.graphics.Rect;
|
|
import android.graphics.SurfaceTexture;
|
|
import android.hardware.camera2.CameraAccessException;
|
|
import android.hardware.camera2.CameraCaptureSession;
|
|
import android.hardware.camera2.CameraDevice;
|
|
import android.hardware.camera2.CaptureRequest;
|
|
import android.hardware.camera2.TotalCaptureResult;
|
|
import android.hardware.camera2.params.OutputConfiguration;
|
|
import android.hardware.camera2.params.SessionConfiguration;
|
|
import android.media.CamcorderProfile;
|
|
import android.media.EncoderProfiles;
|
|
import android.media.Image;
|
|
import android.media.ImageReader;
|
|
import android.media.MediaRecorder;
|
|
import android.os.Build;
|
|
import android.os.Handler;
|
|
import android.os.HandlerThread;
|
|
import android.os.Looper;
|
|
import android.util.Size;
|
|
import android.view.Display;
|
|
import android.view.Surface;
|
|
import com.kofax.mobile.sdk._internal.impl.extraction.rtti.RttiJsonExactionHelper;
|
|
import io.flutter.embedding.engine.systemchannels.PlatformChannel;
|
|
import io.flutter.plugin.common.EventChannel;
|
|
import io.flutter.plugin.common.MethodChannel;
|
|
import io.flutter.plugins.camera.Camera;
|
|
import io.flutter.plugins.camera.CameraCaptureCallback;
|
|
import io.flutter.plugins.camera.ImageSaver;
|
|
import io.flutter.plugins.camera.features.CameraFeature;
|
|
import io.flutter.plugins.camera.features.CameraFeatureFactory;
|
|
import io.flutter.plugins.camera.features.CameraFeatures;
|
|
import io.flutter.plugins.camera.features.Point;
|
|
import io.flutter.plugins.camera.features.autofocus.AutoFocusFeature;
|
|
import io.flutter.plugins.camera.features.autofocus.FocusMode;
|
|
import io.flutter.plugins.camera.features.exposurelock.ExposureLockFeature;
|
|
import io.flutter.plugins.camera.features.exposurelock.ExposureMode;
|
|
import io.flutter.plugins.camera.features.exposureoffset.ExposureOffsetFeature;
|
|
import io.flutter.plugins.camera.features.exposurepoint.ExposurePointFeature;
|
|
import io.flutter.plugins.camera.features.flash.FlashFeature;
|
|
import io.flutter.plugins.camera.features.flash.FlashMode;
|
|
import io.flutter.plugins.camera.features.focuspoint.FocusPointFeature;
|
|
import io.flutter.plugins.camera.features.resolution.ResolutionFeature;
|
|
import io.flutter.plugins.camera.features.resolution.ResolutionPreset;
|
|
import io.flutter.plugins.camera.features.sensororientation.DeviceOrientationManager;
|
|
import io.flutter.plugins.camera.features.zoomlevel.ZoomLevelFeature;
|
|
import io.flutter.plugins.camera.media.MediaRecorderBuilder;
|
|
import io.flutter.plugins.camera.types.CameraCaptureProperties;
|
|
import io.flutter.plugins.camera.types.CaptureTimeoutsWrapper;
|
|
import io.flutter.view.TextureRegistry;
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.nio.ByteBuffer;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.concurrent.Executors;
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* loaded from: classes6.dex */
|
|
public class Camera implements CameraCaptureCallback.CameraCaptureStateListener, ImageReader.OnImageAvailableListener {
|
|
private static final String TAG = "Camera";
|
|
private static final HashMap<String, Integer> supportedImageFormats;
|
|
private final Activity activity;
|
|
private final Context applicationContext;
|
|
private Handler backgroundHandler;
|
|
private HandlerThread backgroundHandlerThread;
|
|
private final CameraCaptureCallback cameraCaptureCallback;
|
|
private CameraDeviceWrapper cameraDevice;
|
|
private final CameraFeatureFactory cameraFeatureFactory;
|
|
private final CameraFeatures cameraFeatures;
|
|
private final CameraProperties cameraProperties;
|
|
private File captureFile;
|
|
private CameraCaptureProperties captureProps;
|
|
private CameraCaptureSession captureSession;
|
|
private CaptureTimeoutsWrapper captureTimeouts;
|
|
private final DartMessenger dartMessenger;
|
|
private final boolean enableAudio;
|
|
private MethodChannel.Result flutterResult;
|
|
private final TextureRegistry.SurfaceTextureEntry flutterTexture;
|
|
private ImageReader imageStreamReader;
|
|
private MediaRecorder mediaRecorder;
|
|
private boolean pausedPreview;
|
|
private ImageReader pictureImageReader;
|
|
private CaptureRequest.Builder previewRequestBuilder;
|
|
private boolean recordingVideo;
|
|
|
|
static {
|
|
HashMap<String, Integer> hashMap = new HashMap<>();
|
|
supportedImageFormats = hashMap;
|
|
hashMap.put("yuv420", 35);
|
|
hashMap.put("jpeg", 256);
|
|
}
|
|
|
|
/* loaded from: classes6.dex */
|
|
class DefaultCameraDeviceWrapper implements CameraDeviceWrapper {
|
|
private final CameraDevice cameraDevice;
|
|
final Camera this$0;
|
|
|
|
private DefaultCameraDeviceWrapper(Camera camera, CameraDevice cameraDevice) {
|
|
this.this$0 = camera;
|
|
this.cameraDevice = cameraDevice;
|
|
}
|
|
|
|
@Override // io.flutter.plugins.camera.CameraDeviceWrapper
|
|
public CaptureRequest.Builder createCaptureRequest(int i) throws CameraAccessException {
|
|
return this.cameraDevice.createCaptureRequest(i);
|
|
}
|
|
|
|
@Override // io.flutter.plugins.camera.CameraDeviceWrapper
|
|
public void createCaptureSession(SessionConfiguration sessionConfiguration) throws CameraAccessException {
|
|
this.cameraDevice.createCaptureSession(sessionConfiguration);
|
|
}
|
|
|
|
@Override // io.flutter.plugins.camera.CameraDeviceWrapper
|
|
public void createCaptureSession(List<Surface> list, CameraCaptureSession.StateCallback stateCallback, Handler handler) throws CameraAccessException {
|
|
this.cameraDevice.createCaptureSession(list, stateCallback, this.this$0.backgroundHandler);
|
|
}
|
|
|
|
@Override // io.flutter.plugins.camera.CameraDeviceWrapper
|
|
public void close() {
|
|
this.cameraDevice.close();
|
|
}
|
|
}
|
|
|
|
public Camera(Activity activity, TextureRegistry.SurfaceTextureEntry surfaceTextureEntry, CameraFeatureFactory cameraFeatureFactory, DartMessenger dartMessenger, CameraProperties cameraProperties, ResolutionPreset resolutionPreset, boolean z) {
|
|
if (activity == null) {
|
|
throw new IllegalStateException("No activity available!");
|
|
}
|
|
this.activity = activity;
|
|
this.enableAudio = z;
|
|
this.flutterTexture = surfaceTextureEntry;
|
|
this.dartMessenger = dartMessenger;
|
|
this.applicationContext = activity.getApplicationContext();
|
|
this.cameraProperties = cameraProperties;
|
|
this.cameraFeatureFactory = cameraFeatureFactory;
|
|
this.cameraFeatures = CameraFeatures.init(cameraFeatureFactory, cameraProperties, activity, dartMessenger, resolutionPreset);
|
|
this.captureTimeouts = new CaptureTimeoutsWrapper(3000L, 3000L);
|
|
CameraCaptureProperties cameraCaptureProperties = new CameraCaptureProperties();
|
|
this.captureProps = cameraCaptureProperties;
|
|
this.cameraCaptureCallback = CameraCaptureCallback.create(this, this.captureTimeouts, cameraCaptureProperties);
|
|
startBackgroundThread();
|
|
}
|
|
|
|
@Override // io.flutter.plugins.camera.CameraCaptureCallback.CameraCaptureStateListener
|
|
public void onConverged() {
|
|
takePictureAfterPrecapture();
|
|
}
|
|
|
|
@Override // io.flutter.plugins.camera.CameraCaptureCallback.CameraCaptureStateListener
|
|
public void onPrecapture() {
|
|
runPrecaptureSequence();
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public void updateBuilderSettings(CaptureRequest.Builder builder) {
|
|
for (CameraFeature cameraFeature : this.cameraFeatures.getAllFeatures()) {
|
|
cameraFeature.getDebugName();
|
|
cameraFeature.updateBuilder(builder);
|
|
}
|
|
}
|
|
|
|
private void prepareMediaRecorder(String str) throws IOException {
|
|
MediaRecorderBuilder mediaRecorderBuilder;
|
|
int videoOrientation;
|
|
MediaRecorder mediaRecorder = this.mediaRecorder;
|
|
if (mediaRecorder != null) {
|
|
mediaRecorder.release();
|
|
}
|
|
PlatformChannel.DeviceOrientation lockedCaptureOrientation = this.cameraFeatures.getSensorOrientation().getLockedCaptureOrientation();
|
|
EncoderProfiles recordingProfile = getRecordingProfile();
|
|
if (Build.VERSION.SDK_INT >= 31 && recordingProfile != null) {
|
|
mediaRecorderBuilder = new MediaRecorderBuilder(recordingProfile, str);
|
|
} else {
|
|
mediaRecorderBuilder = new MediaRecorderBuilder(getRecordingProfileLegacy(), str);
|
|
}
|
|
MediaRecorderBuilder enableAudio = mediaRecorderBuilder.setEnableAudio(this.enableAudio);
|
|
if (lockedCaptureOrientation == null) {
|
|
videoOrientation = getDeviceOrientationManager().getVideoOrientation();
|
|
} else {
|
|
videoOrientation = getDeviceOrientationManager().getVideoOrientation(lockedCaptureOrientation);
|
|
}
|
|
this.mediaRecorder = enableAudio.setMediaOrientation(videoOrientation).build();
|
|
}
|
|
|
|
public void open(String str) throws CameraAccessException {
|
|
ResolutionFeature resolution = this.cameraFeatures.getResolution();
|
|
if (!resolution.checkIsSupported()) {
|
|
DartMessenger dartMessenger = this.dartMessenger;
|
|
StringBuilder sb = new StringBuilder("Camera with name \"");
|
|
sb.append(this.cameraProperties.getCameraName());
|
|
sb.append("\" is not supported by this plugin.");
|
|
dartMessenger.sendCameraErrorEvent(sb.toString());
|
|
return;
|
|
}
|
|
this.pictureImageReader = ImageReader.newInstance(resolution.getCaptureSize().getWidth(), resolution.getCaptureSize().getHeight(), 256, 1);
|
|
Integer num = supportedImageFormats.get(str);
|
|
if (num == null) {
|
|
num = 35;
|
|
}
|
|
this.imageStreamReader = ImageReader.newInstance(resolution.getPreviewSize().getWidth(), resolution.getPreviewSize().getHeight(), num.intValue(), 1);
|
|
CameraUtils.getCameraManager(this.activity).openCamera(this.cameraProperties.getCameraName(), new CameraDevice.StateCallback(this, resolution) { // from class: io.flutter.plugins.camera.Camera.1
|
|
final Camera this$0;
|
|
final ResolutionFeature val$resolutionFeature;
|
|
|
|
{
|
|
this.this$0 = this;
|
|
this.val$resolutionFeature = resolution;
|
|
}
|
|
|
|
@Override // android.hardware.camera2.CameraDevice.StateCallback
|
|
public void onOpened(CameraDevice cameraDevice) {
|
|
Camera camera = this.this$0;
|
|
camera.cameraDevice = new DefaultCameraDeviceWrapper(cameraDevice);
|
|
try {
|
|
this.this$0.startPreview();
|
|
DartMessenger dartMessenger2 = this.this$0.dartMessenger;
|
|
int width = this.val$resolutionFeature.getPreviewSize().getWidth();
|
|
int height = this.val$resolutionFeature.getPreviewSize().getHeight();
|
|
dartMessenger2.sendCameraInitializedEvent(Integer.valueOf(width), Integer.valueOf(height), this.this$0.cameraFeatures.getExposureLock().getValue(), this.this$0.cameraFeatures.getAutoFocus().getValue(), Boolean.valueOf(this.this$0.cameraFeatures.getExposurePoint().checkIsSupported()), Boolean.valueOf(this.this$0.cameraFeatures.getFocusPoint().checkIsSupported()));
|
|
} catch (CameraAccessException e) {
|
|
this.this$0.dartMessenger.sendCameraErrorEvent(e.getMessage());
|
|
this.this$0.close();
|
|
}
|
|
}
|
|
|
|
@Override // android.hardware.camera2.CameraDevice.StateCallback
|
|
public void onClosed(CameraDevice cameraDevice) {
|
|
this.this$0.cameraDevice = null;
|
|
this.this$0.closeCaptureSession();
|
|
this.this$0.dartMessenger.sendCameraClosingEvent();
|
|
}
|
|
|
|
@Override // android.hardware.camera2.CameraDevice.StateCallback
|
|
public void onDisconnected(CameraDevice cameraDevice) {
|
|
this.this$0.close();
|
|
this.this$0.dartMessenger.sendCameraErrorEvent("The camera was disconnected.");
|
|
}
|
|
|
|
@Override // android.hardware.camera2.CameraDevice.StateCallback
|
|
public void onError(CameraDevice cameraDevice, int i) {
|
|
this.this$0.close();
|
|
this.this$0.dartMessenger.sendCameraErrorEvent(i != 1 ? i != 2 ? i != 3 ? i != 4 ? i != 5 ? "Unknown camera error" : "The camera service has encountered a fatal error." : "The camera device has encountered a fatal error" : "The camera device could not be opened due to a device policy." : "Max cameras in use" : "The camera device is in use already.");
|
|
}
|
|
}, this.backgroundHandler);
|
|
}
|
|
|
|
void createCaptureSession(int i, Surface... surfaceArr) throws CameraAccessException {
|
|
createCaptureSession(i, null, surfaceArr);
|
|
}
|
|
|
|
private void createCaptureSession(int i, Runnable runnable, Surface... surfaceArr) throws CameraAccessException {
|
|
this.captureSession = null;
|
|
this.previewRequestBuilder = this.cameraDevice.createCaptureRequest(i);
|
|
ResolutionFeature resolution = this.cameraFeatures.getResolution();
|
|
SurfaceTexture surfaceTexture = this.flutterTexture.surfaceTexture();
|
|
surfaceTexture.setDefaultBufferSize(resolution.getPreviewSize().getWidth(), resolution.getPreviewSize().getHeight());
|
|
Surface surface = new Surface(surfaceTexture);
|
|
this.previewRequestBuilder.addTarget(surface);
|
|
List asList = Arrays.asList(surfaceArr);
|
|
if (i != 1) {
|
|
Iterator it = asList.iterator();
|
|
while (it.hasNext()) {
|
|
this.previewRequestBuilder.addTarget((Surface) it.next());
|
|
}
|
|
}
|
|
Size cameraBoundaries = CameraRegionUtils.getCameraBoundaries(this.cameraProperties, this.previewRequestBuilder);
|
|
this.cameraFeatures.getExposurePoint().setCameraBoundaries(cameraBoundaries);
|
|
this.cameraFeatures.getFocusPoint().setCameraBoundaries(cameraBoundaries);
|
|
CameraCaptureSession.StateCallback anonymousClass2 = new AnonymousClass2(this, runnable);
|
|
if (Build.VERSION.SDK_INT >= 28) {
|
|
List<OutputConfiguration> arrayList = new ArrayList<>();
|
|
arrayList.add(new OutputConfiguration(surface));
|
|
Iterator it2 = asList.iterator();
|
|
while (it2.hasNext()) {
|
|
arrayList.add(new OutputConfiguration((Surface) it2.next()));
|
|
}
|
|
createCaptureSessionWithSessionConfig(arrayList, anonymousClass2);
|
|
return;
|
|
}
|
|
List<Surface> arrayList2 = new ArrayList<>();
|
|
arrayList2.add(surface);
|
|
arrayList2.addAll(asList);
|
|
createCaptureSession(arrayList2, anonymousClass2);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* renamed from: io.flutter.plugins.camera.Camera$2, reason: invalid class name */
|
|
/* loaded from: classes6.dex */
|
|
public class AnonymousClass2 extends CameraCaptureSession.StateCallback {
|
|
boolean captureSessionClosed = false;
|
|
final Camera this$0;
|
|
final Runnable val$onSuccessCallback;
|
|
|
|
AnonymousClass2(Camera camera, Runnable runnable) {
|
|
this.this$0 = camera;
|
|
this.val$onSuccessCallback = runnable;
|
|
}
|
|
|
|
@Override // android.hardware.camera2.CameraCaptureSession.StateCallback
|
|
public void onConfigured(CameraCaptureSession cameraCaptureSession) {
|
|
if (this.this$0.cameraDevice == null || this.captureSessionClosed) {
|
|
this.this$0.dartMessenger.sendCameraErrorEvent("The camera was closed during configuration.");
|
|
return;
|
|
}
|
|
this.this$0.captureSession = cameraCaptureSession;
|
|
Camera camera = this.this$0;
|
|
camera.updateBuilderSettings(camera.previewRequestBuilder);
|
|
this.this$0.refreshPreviewCaptureSession(this.val$onSuccessCallback, new ErrorCallback(this) { // from class: io.flutter.plugins.camera.Camera$2$$ExternalSyntheticLambda0
|
|
public final Camera.AnonymousClass2 f$0;
|
|
|
|
@Override // io.flutter.plugins.camera.ErrorCallback
|
|
public final void onError(String str, String str2) {
|
|
this.f$0.m346lambda$onConfigured$0$ioflutterpluginscameraCamera$2(str, str2);
|
|
}
|
|
|
|
{
|
|
this.f$0 = this;
|
|
}
|
|
});
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* renamed from: lambda$onConfigured$0$io-flutter-plugins-camera-Camera$2, reason: not valid java name */
|
|
public /* synthetic */ void m346lambda$onConfigured$0$ioflutterpluginscameraCamera$2(String str, String str2) {
|
|
this.this$0.dartMessenger.sendCameraErrorEvent(str2);
|
|
}
|
|
|
|
@Override // android.hardware.camera2.CameraCaptureSession.StateCallback
|
|
public void onConfigureFailed(CameraCaptureSession cameraCaptureSession) {
|
|
this.this$0.dartMessenger.sendCameraErrorEvent("Failed to configure camera session.");
|
|
}
|
|
|
|
@Override // android.hardware.camera2.CameraCaptureSession.StateCallback
|
|
public void onClosed(CameraCaptureSession cameraCaptureSession) {
|
|
this.captureSessionClosed = true;
|
|
}
|
|
}
|
|
|
|
private void createCaptureSessionWithSessionConfig(List<OutputConfiguration> list, CameraCaptureSession.StateCallback stateCallback) throws CameraAccessException {
|
|
this.cameraDevice.createCaptureSession(new SessionConfiguration(0, list, Executors.newSingleThreadExecutor(), stateCallback));
|
|
}
|
|
|
|
private void createCaptureSession(List<Surface> list, CameraCaptureSession.StateCallback stateCallback) throws CameraAccessException {
|
|
this.cameraDevice.createCaptureSession(list, stateCallback, this.backgroundHandler);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public void refreshPreviewCaptureSession(Runnable runnable, ErrorCallback errorCallback) {
|
|
CameraCaptureSession cameraCaptureSession = this.captureSession;
|
|
if (cameraCaptureSession == null) {
|
|
return;
|
|
}
|
|
try {
|
|
if (!this.pausedPreview) {
|
|
cameraCaptureSession.setRepeatingRequest(this.previewRequestBuilder.build(), this.cameraCaptureCallback, this.backgroundHandler);
|
|
}
|
|
if (runnable != null) {
|
|
runnable.run();
|
|
}
|
|
} catch (CameraAccessException e) {
|
|
errorCallback.onError("cameraAccess", e.getMessage());
|
|
} catch (IllegalStateException e2) {
|
|
StringBuilder sb = new StringBuilder("Camera is closed: ");
|
|
sb.append(e2.getMessage());
|
|
errorCallback.onError("cameraAccess", sb.toString());
|
|
}
|
|
}
|
|
|
|
private void startCapture(boolean z, boolean z2) throws CameraAccessException {
|
|
Runnable runnable;
|
|
ArrayList arrayList = new ArrayList();
|
|
if (z) {
|
|
arrayList.add(this.mediaRecorder.getSurface());
|
|
runnable = new Runnable(this) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda17
|
|
public final Camera f$0;
|
|
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
this.f$0.m344lambda$startCapture$0$ioflutterpluginscameraCamera();
|
|
}
|
|
|
|
{
|
|
this.f$0 = this;
|
|
}
|
|
};
|
|
} else {
|
|
runnable = null;
|
|
}
|
|
if (z2) {
|
|
arrayList.add(this.imageStreamReader.getSurface());
|
|
}
|
|
createCaptureSession(3, runnable, (Surface[]) arrayList.toArray(new Surface[0]));
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* renamed from: lambda$startCapture$0$io-flutter-plugins-camera-Camera, reason: not valid java name */
|
|
public /* synthetic */ void m344lambda$startCapture$0$ioflutterpluginscameraCamera() {
|
|
this.mediaRecorder.start();
|
|
}
|
|
|
|
public void takePicture(MethodChannel.Result result) {
|
|
if (this.cameraCaptureCallback.getCameraState() != CameraState.STATE_PREVIEW) {
|
|
result.error("captureAlreadyActive", "Picture is currently already being captured", null);
|
|
return;
|
|
}
|
|
this.flutterResult = result;
|
|
try {
|
|
this.captureFile = File.createTempFile("CAP", ".jpg", this.applicationContext.getCacheDir());
|
|
this.captureTimeouts.reset();
|
|
this.pictureImageReader.setOnImageAvailableListener(this, this.backgroundHandler);
|
|
AutoFocusFeature autoFocus = this.cameraFeatures.getAutoFocus();
|
|
if (autoFocus.checkIsSupported() && autoFocus.getValue() == FocusMode.auto) {
|
|
runPictureAutoFocus();
|
|
} else {
|
|
runPrecaptureSequence();
|
|
}
|
|
} catch (IOException | SecurityException e) {
|
|
this.dartMessenger.error(this.flutterResult, "cannotCreateFile", e.getMessage(), null);
|
|
}
|
|
}
|
|
|
|
private void runPrecaptureSequence() {
|
|
try {
|
|
this.previewRequestBuilder.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER, 0);
|
|
this.captureSession.capture(this.previewRequestBuilder.build(), this.cameraCaptureCallback, this.backgroundHandler);
|
|
refreshPreviewCaptureSession(null, new ErrorCallback(this) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda1
|
|
public final Camera f$0;
|
|
|
|
@Override // io.flutter.plugins.camera.ErrorCallback
|
|
public final void onError(String str, String str2) {
|
|
this.f$0.m342lambda$runPrecaptureSequence$1$ioflutterpluginscameraCamera(str, str2);
|
|
}
|
|
|
|
{
|
|
this.f$0 = this;
|
|
}
|
|
});
|
|
this.cameraCaptureCallback.setCameraState(CameraState.STATE_WAITING_PRECAPTURE_START);
|
|
this.previewRequestBuilder.set(CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER, 1);
|
|
this.captureSession.capture(this.previewRequestBuilder.build(), this.cameraCaptureCallback, this.backgroundHandler);
|
|
} catch (CameraAccessException unused) {
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* renamed from: lambda$runPrecaptureSequence$1$io-flutter-plugins-camera-Camera, reason: not valid java name */
|
|
public /* synthetic */ void m342lambda$runPrecaptureSequence$1$ioflutterpluginscameraCamera(String str, String str2) {
|
|
this.dartMessenger.error(this.flutterResult, "cameraAccess", str2, null);
|
|
}
|
|
|
|
private void takePictureAfterPrecapture() {
|
|
int photoOrientation;
|
|
this.cameraCaptureCallback.setCameraState(CameraState.STATE_CAPTURING);
|
|
CameraDeviceWrapper cameraDeviceWrapper = this.cameraDevice;
|
|
if (cameraDeviceWrapper == null) {
|
|
return;
|
|
}
|
|
try {
|
|
CaptureRequest.Builder createCaptureRequest = cameraDeviceWrapper.createCaptureRequest(2);
|
|
createCaptureRequest.addTarget(this.pictureImageReader.getSurface());
|
|
createCaptureRequest.set(CaptureRequest.SCALER_CROP_REGION, (Rect) this.previewRequestBuilder.get(CaptureRequest.SCALER_CROP_REGION));
|
|
updateBuilderSettings(createCaptureRequest);
|
|
PlatformChannel.DeviceOrientation lockedCaptureOrientation = this.cameraFeatures.getSensorOrientation().getLockedCaptureOrientation();
|
|
CaptureRequest.Key key = CaptureRequest.JPEG_ORIENTATION;
|
|
if (lockedCaptureOrientation == null) {
|
|
photoOrientation = getDeviceOrientationManager().getPhotoOrientation();
|
|
} else {
|
|
photoOrientation = getDeviceOrientationManager().getPhotoOrientation(lockedCaptureOrientation);
|
|
}
|
|
createCaptureRequest.set(key, Integer.valueOf(photoOrientation));
|
|
CameraCaptureSession.CaptureCallback captureCallback = new CameraCaptureSession.CaptureCallback(this) { // from class: io.flutter.plugins.camera.Camera.3
|
|
final Camera this$0;
|
|
|
|
{
|
|
this.this$0 = this;
|
|
}
|
|
|
|
@Override // android.hardware.camera2.CameraCaptureSession.CaptureCallback
|
|
public void onCaptureCompleted(CameraCaptureSession cameraCaptureSession, CaptureRequest captureRequest, TotalCaptureResult totalCaptureResult) {
|
|
this.this$0.unlockAutoFocus();
|
|
}
|
|
};
|
|
try {
|
|
this.captureSession.stopRepeating();
|
|
this.captureSession.capture(createCaptureRequest.build(), captureCallback, this.backgroundHandler);
|
|
} catch (CameraAccessException e) {
|
|
this.dartMessenger.error(this.flutterResult, "cameraAccess", e.getMessage(), null);
|
|
}
|
|
} catch (CameraAccessException e2) {
|
|
this.dartMessenger.error(this.flutterResult, "cameraAccess", e2.getMessage(), null);
|
|
}
|
|
}
|
|
|
|
private Display getDefaultDisplay() {
|
|
return this.activity.getWindowManager().getDefaultDisplay();
|
|
}
|
|
|
|
public void startBackgroundThread() {
|
|
if (this.backgroundHandlerThread != null) {
|
|
return;
|
|
}
|
|
HandlerThread create = HandlerThreadFactory.create("CameraBackground");
|
|
this.backgroundHandlerThread = create;
|
|
try {
|
|
create.start();
|
|
} catch (IllegalThreadStateException unused) {
|
|
}
|
|
this.backgroundHandler = HandlerFactory.create(this.backgroundHandlerThread.getLooper());
|
|
}
|
|
|
|
public void stopBackgroundThread() {
|
|
HandlerThread handlerThread = this.backgroundHandlerThread;
|
|
if (handlerThread != null) {
|
|
handlerThread.quitSafely();
|
|
}
|
|
this.backgroundHandlerThread = null;
|
|
this.backgroundHandler = null;
|
|
}
|
|
|
|
private void runPictureAutoFocus() {
|
|
this.cameraCaptureCallback.setCameraState(CameraState.STATE_WAITING_FOCUS);
|
|
lockAutoFocus();
|
|
}
|
|
|
|
private void lockAutoFocus() {
|
|
if (this.captureSession == null) {
|
|
return;
|
|
}
|
|
this.previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, 1);
|
|
try {
|
|
this.captureSession.capture(this.previewRequestBuilder.build(), null, this.backgroundHandler);
|
|
} catch (CameraAccessException e) {
|
|
this.dartMessenger.sendCameraErrorEvent(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public void unlockAutoFocus() {
|
|
if (this.captureSession == null) {
|
|
return;
|
|
}
|
|
try {
|
|
this.previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, 2);
|
|
this.captureSession.capture(this.previewRequestBuilder.build(), null, this.backgroundHandler);
|
|
this.previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, 0);
|
|
this.captureSession.capture(this.previewRequestBuilder.build(), null, this.backgroundHandler);
|
|
refreshPreviewCaptureSession(null, new ErrorCallback(this) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda8
|
|
public final Camera f$0;
|
|
|
|
@Override // io.flutter.plugins.camera.ErrorCallback
|
|
public final void onError(String str, String str2) {
|
|
this.f$0.m345lambda$unlockAutoFocus$2$ioflutterpluginscameraCamera(str, str2);
|
|
}
|
|
|
|
{
|
|
this.f$0 = this;
|
|
}
|
|
});
|
|
} catch (CameraAccessException e) {
|
|
this.dartMessenger.sendCameraErrorEvent(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* renamed from: lambda$unlockAutoFocus$2$io-flutter-plugins-camera-Camera, reason: not valid java name */
|
|
public /* synthetic */ void m345lambda$unlockAutoFocus$2$ioflutterpluginscameraCamera(String str, String str2) {
|
|
this.dartMessenger.error(this.flutterResult, str, str2, null);
|
|
}
|
|
|
|
public void startVideoRecording(MethodChannel.Result result, EventChannel eventChannel) {
|
|
prepareRecording(result);
|
|
if (eventChannel != null) {
|
|
setStreamHandler(eventChannel);
|
|
}
|
|
this.recordingVideo = true;
|
|
try {
|
|
startCapture(true, eventChannel != null);
|
|
result.success(null);
|
|
} catch (CameraAccessException e) {
|
|
this.recordingVideo = false;
|
|
this.captureFile = null;
|
|
result.error("videoRecordingFailed", e.getMessage(), null);
|
|
}
|
|
}
|
|
|
|
public void stopVideoRecording(MethodChannel.Result result) {
|
|
if (!this.recordingVideo) {
|
|
result.success(null);
|
|
return;
|
|
}
|
|
this.cameraFeatures.setAutoFocus(this.cameraFeatureFactory.createAutoFocusFeature(this.cameraProperties, false));
|
|
this.recordingVideo = false;
|
|
try {
|
|
this.captureSession.abortCaptures();
|
|
this.mediaRecorder.stop();
|
|
} catch (CameraAccessException | IllegalStateException unused) {
|
|
}
|
|
this.mediaRecorder.reset();
|
|
try {
|
|
startPreview();
|
|
result.success(this.captureFile.getAbsolutePath());
|
|
this.captureFile = null;
|
|
} catch (CameraAccessException | IllegalStateException e) {
|
|
result.error("videoRecordingFailed", e.getMessage(), null);
|
|
}
|
|
}
|
|
|
|
public void pauseVideoRecording(MethodChannel.Result result) {
|
|
if (!this.recordingVideo) {
|
|
result.success(null);
|
|
return;
|
|
}
|
|
try {
|
|
this.mediaRecorder.pause();
|
|
result.success(null);
|
|
} catch (IllegalStateException e) {
|
|
result.error("videoRecordingFailed", e.getMessage(), null);
|
|
}
|
|
}
|
|
|
|
public void resumeVideoRecording(MethodChannel.Result result) {
|
|
if (!this.recordingVideo) {
|
|
result.success(null);
|
|
return;
|
|
}
|
|
try {
|
|
this.mediaRecorder.resume();
|
|
result.success(null);
|
|
} catch (IllegalStateException e) {
|
|
result.error("videoRecordingFailed", e.getMessage(), null);
|
|
}
|
|
}
|
|
|
|
public void setFlashMode(final MethodChannel.Result result, FlashMode flashMode) {
|
|
FlashFeature flash = this.cameraFeatures.getFlash();
|
|
flash.setValue(flashMode);
|
|
flash.updateBuilder(this.previewRequestBuilder);
|
|
refreshPreviewCaptureSession(new Runnable(result) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda0
|
|
public final MethodChannel.Result f$0;
|
|
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
this.f$0.success(null);
|
|
}
|
|
|
|
{
|
|
this.f$0 = result;
|
|
}
|
|
}, new ErrorCallback(result) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda9
|
|
public final MethodChannel.Result f$0;
|
|
|
|
@Override // io.flutter.plugins.camera.ErrorCallback
|
|
public final void onError(String str, String str2) {
|
|
this.f$0.error("setFlashModeFailed", "Could not set flash mode.", null);
|
|
}
|
|
|
|
{
|
|
this.f$0 = result;
|
|
}
|
|
});
|
|
}
|
|
|
|
public void setExposureMode(final MethodChannel.Result result, ExposureMode exposureMode) {
|
|
ExposureLockFeature exposureLock = this.cameraFeatures.getExposureLock();
|
|
exposureLock.setValue(exposureMode);
|
|
exposureLock.updateBuilder(this.previewRequestBuilder);
|
|
refreshPreviewCaptureSession(new Runnable(result) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda14
|
|
public final MethodChannel.Result f$0;
|
|
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
this.f$0.success(null);
|
|
}
|
|
|
|
{
|
|
this.f$0 = result;
|
|
}
|
|
}, new ErrorCallback(result) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda15
|
|
public final MethodChannel.Result f$0;
|
|
|
|
@Override // io.flutter.plugins.camera.ErrorCallback
|
|
public final void onError(String str, String str2) {
|
|
this.f$0.error("setExposureModeFailed", "Could not set exposure mode.", null);
|
|
}
|
|
|
|
{
|
|
this.f$0 = result;
|
|
}
|
|
});
|
|
}
|
|
|
|
public void setExposurePoint(final MethodChannel.Result result, Point point) {
|
|
ExposurePointFeature exposurePoint = this.cameraFeatures.getExposurePoint();
|
|
exposurePoint.setValue(point);
|
|
exposurePoint.updateBuilder(this.previewRequestBuilder);
|
|
refreshPreviewCaptureSession(new Runnable(result) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda2
|
|
public final MethodChannel.Result f$0;
|
|
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
this.f$0.success(null);
|
|
}
|
|
|
|
{
|
|
this.f$0 = result;
|
|
}
|
|
}, new ErrorCallback(result) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda3
|
|
public final MethodChannel.Result f$0;
|
|
|
|
@Override // io.flutter.plugins.camera.ErrorCallback
|
|
public final void onError(String str, String str2) {
|
|
this.f$0.error("setExposurePointFailed", "Could not set exposure point.", null);
|
|
}
|
|
|
|
{
|
|
this.f$0 = result;
|
|
}
|
|
});
|
|
}
|
|
|
|
public double getMaxExposureOffset() {
|
|
return this.cameraFeatures.getExposureOffset().getMaxExposureOffset();
|
|
}
|
|
|
|
public double getMinExposureOffset() {
|
|
return this.cameraFeatures.getExposureOffset().getMinExposureOffset();
|
|
}
|
|
|
|
public double getExposureOffsetStepSize() {
|
|
return this.cameraFeatures.getExposureOffset().getExposureOffsetStepSize();
|
|
}
|
|
|
|
public void setFocusMode(MethodChannel.Result result, FocusMode focusMode) {
|
|
AutoFocusFeature autoFocus = this.cameraFeatures.getAutoFocus();
|
|
autoFocus.setValue(focusMode);
|
|
autoFocus.updateBuilder(this.previewRequestBuilder);
|
|
if (!this.pausedPreview) {
|
|
int i = AnonymousClass6.$SwitchMap$io$flutter$plugins$camera$features$autofocus$FocusMode[focusMode.ordinal()];
|
|
if (i != 1) {
|
|
if (i == 2) {
|
|
unlockAutoFocus();
|
|
}
|
|
} else {
|
|
if (this.captureSession == null) {
|
|
return;
|
|
}
|
|
lockAutoFocus();
|
|
this.previewRequestBuilder.set(CaptureRequest.CONTROL_AF_TRIGGER, 0);
|
|
try {
|
|
this.captureSession.setRepeatingRequest(this.previewRequestBuilder.build(), null, this.backgroundHandler);
|
|
} catch (CameraAccessException e) {
|
|
if (result != null) {
|
|
StringBuilder sb = new StringBuilder("Error setting focus mode: ");
|
|
sb.append(e.getMessage());
|
|
result.error("setFocusModeFailed", sb.toString(), null);
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (result != null) {
|
|
result.success(null);
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* renamed from: io.flutter.plugins.camera.Camera$6, reason: invalid class name */
|
|
/* loaded from: classes6.dex */
|
|
public static /* synthetic */ class AnonymousClass6 {
|
|
static final int[] $SwitchMap$io$flutter$plugins$camera$features$autofocus$FocusMode;
|
|
|
|
static {
|
|
int[] iArr = new int[FocusMode.values().length];
|
|
$SwitchMap$io$flutter$plugins$camera$features$autofocus$FocusMode = iArr;
|
|
try {
|
|
iArr[FocusMode.locked.ordinal()] = 1;
|
|
} catch (NoSuchFieldError unused) {
|
|
}
|
|
try {
|
|
$SwitchMap$io$flutter$plugins$camera$features$autofocus$FocusMode[FocusMode.auto.ordinal()] = 2;
|
|
} catch (NoSuchFieldError unused2) {
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setFocusPoint(final MethodChannel.Result result, Point point) {
|
|
FocusPointFeature focusPoint = this.cameraFeatures.getFocusPoint();
|
|
focusPoint.setValue(point);
|
|
focusPoint.updateBuilder(this.previewRequestBuilder);
|
|
refreshPreviewCaptureSession(new Runnable(result) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda4
|
|
public final MethodChannel.Result f$0;
|
|
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
this.f$0.success(null);
|
|
}
|
|
|
|
{
|
|
this.f$0 = result;
|
|
}
|
|
}, new ErrorCallback(result) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda5
|
|
public final MethodChannel.Result f$0;
|
|
|
|
@Override // io.flutter.plugins.camera.ErrorCallback
|
|
public final void onError(String str, String str2) {
|
|
this.f$0.error("setFocusPointFailed", "Could not set focus point.", null);
|
|
}
|
|
|
|
{
|
|
this.f$0 = result;
|
|
}
|
|
});
|
|
setFocusMode(null, this.cameraFeatures.getAutoFocus().getValue());
|
|
}
|
|
|
|
public void setExposureOffset(final MethodChannel.Result result, double d) {
|
|
final ExposureOffsetFeature exposureOffset = this.cameraFeatures.getExposureOffset();
|
|
exposureOffset.setValue(Double.valueOf(d));
|
|
exposureOffset.updateBuilder(this.previewRequestBuilder);
|
|
refreshPreviewCaptureSession(new Runnable(result, exposureOffset) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda10
|
|
public final MethodChannel.Result f$0;
|
|
public final ExposureOffsetFeature f$1;
|
|
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
this.f$0.success(this.f$1.getValue());
|
|
}
|
|
|
|
{
|
|
this.f$0 = result;
|
|
this.f$1 = exposureOffset;
|
|
}
|
|
}, new ErrorCallback(result) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda11
|
|
public final MethodChannel.Result f$0;
|
|
|
|
@Override // io.flutter.plugins.camera.ErrorCallback
|
|
public final void onError(String str, String str2) {
|
|
this.f$0.error("setExposureOffsetFailed", "Could not set exposure offset.", null);
|
|
}
|
|
|
|
{
|
|
this.f$0 = result;
|
|
}
|
|
});
|
|
}
|
|
|
|
public float getMaxZoomLevel() {
|
|
return this.cameraFeatures.getZoomLevel().getMaximumZoomLevel();
|
|
}
|
|
|
|
public float getMinZoomLevel() {
|
|
return this.cameraFeatures.getZoomLevel().getMinimumZoomLevel();
|
|
}
|
|
|
|
CamcorderProfile getRecordingProfileLegacy() {
|
|
return this.cameraFeatures.getResolution().getRecordingProfileLegacy();
|
|
}
|
|
|
|
EncoderProfiles getRecordingProfile() {
|
|
return this.cameraFeatures.getResolution().getRecordingProfile();
|
|
}
|
|
|
|
DeviceOrientationManager getDeviceOrientationManager() {
|
|
return this.cameraFeatures.getSensorOrientation().getDeviceOrientationManager();
|
|
}
|
|
|
|
public void setZoomLevel(final MethodChannel.Result result, float f) throws CameraAccessException {
|
|
ZoomLevelFeature zoomLevel = this.cameraFeatures.getZoomLevel();
|
|
float maximumZoomLevel = zoomLevel.getMaximumZoomLevel();
|
|
float minimumZoomLevel = zoomLevel.getMinimumZoomLevel();
|
|
if (f > maximumZoomLevel || f < minimumZoomLevel) {
|
|
result.error("ZOOM_ERROR", String.format(Locale.ENGLISH, "Zoom level out of bounds (zoom level should be between %f and %f).", Float.valueOf(minimumZoomLevel), Float.valueOf(maximumZoomLevel)), null);
|
|
return;
|
|
}
|
|
zoomLevel.setValue(Float.valueOf(f));
|
|
zoomLevel.updateBuilder(this.previewRequestBuilder);
|
|
refreshPreviewCaptureSession(new Runnable(result) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda12
|
|
public final MethodChannel.Result f$0;
|
|
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
this.f$0.success(null);
|
|
}
|
|
|
|
{
|
|
this.f$0 = result;
|
|
}
|
|
}, new ErrorCallback(result) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda13
|
|
public final MethodChannel.Result f$0;
|
|
|
|
@Override // io.flutter.plugins.camera.ErrorCallback
|
|
public final void onError(String str, String str2) {
|
|
this.f$0.error("setZoomLevelFailed", "Could not set zoom level.", null);
|
|
}
|
|
|
|
{
|
|
this.f$0 = result;
|
|
}
|
|
});
|
|
}
|
|
|
|
public void lockCaptureOrientation(PlatformChannel.DeviceOrientation deviceOrientation) {
|
|
this.cameraFeatures.getSensorOrientation().lockCaptureOrientation(deviceOrientation);
|
|
}
|
|
|
|
public void unlockCaptureOrientation() {
|
|
this.cameraFeatures.getSensorOrientation().unlockCaptureOrientation();
|
|
}
|
|
|
|
public void pausePreview() throws CameraAccessException {
|
|
this.pausedPreview = true;
|
|
this.captureSession.stopRepeating();
|
|
}
|
|
|
|
public void resumePreview() {
|
|
this.pausedPreview = false;
|
|
refreshPreviewCaptureSession(null, new ErrorCallback(this) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda6
|
|
public final Camera f$0;
|
|
|
|
@Override // io.flutter.plugins.camera.ErrorCallback
|
|
public final void onError(String str, String str2) {
|
|
this.f$0.m341lambda$resumePreview$15$ioflutterpluginscameraCamera(str, str2);
|
|
}
|
|
|
|
{
|
|
this.f$0 = this;
|
|
}
|
|
});
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* renamed from: lambda$resumePreview$15$io-flutter-plugins-camera-Camera, reason: not valid java name */
|
|
public /* synthetic */ void m341lambda$resumePreview$15$ioflutterpluginscameraCamera(String str, String str2) {
|
|
this.dartMessenger.sendCameraErrorEvent(str2);
|
|
}
|
|
|
|
public void startPreview() throws CameraAccessException {
|
|
ImageReader imageReader = this.pictureImageReader;
|
|
if (imageReader == null || imageReader.getSurface() == null) {
|
|
return;
|
|
}
|
|
createCaptureSession(1, this.pictureImageReader.getSurface());
|
|
}
|
|
|
|
public void startPreviewWithImageStream(EventChannel eventChannel) throws CameraAccessException {
|
|
setStreamHandler(eventChannel);
|
|
startCapture(false, true);
|
|
}
|
|
|
|
@Override // android.media.ImageReader.OnImageAvailableListener
|
|
public void onImageAvailable(ImageReader imageReader) {
|
|
this.backgroundHandler.post(new ImageSaver(imageReader.acquireNextImage(), this.captureFile, new ImageSaver.Callback(this) { // from class: io.flutter.plugins.camera.Camera.4
|
|
final Camera this$0;
|
|
|
|
{
|
|
this.this$0 = this;
|
|
}
|
|
|
|
@Override // io.flutter.plugins.camera.ImageSaver.Callback
|
|
public void onComplete(String str) {
|
|
this.this$0.dartMessenger.finish(this.this$0.flutterResult, str);
|
|
}
|
|
|
|
@Override // io.flutter.plugins.camera.ImageSaver.Callback
|
|
public void onError(String str, String str2) {
|
|
this.this$0.dartMessenger.error(this.this$0.flutterResult, str, str2, null);
|
|
}
|
|
}));
|
|
this.cameraCaptureCallback.setCameraState(CameraState.STATE_PREVIEW);
|
|
}
|
|
|
|
private void prepareRecording(MethodChannel.Result result) {
|
|
try {
|
|
File createTempFile = File.createTempFile("REC", ".mp4", this.applicationContext.getCacheDir());
|
|
this.captureFile = createTempFile;
|
|
try {
|
|
prepareMediaRecorder(createTempFile.getAbsolutePath());
|
|
this.cameraFeatures.setAutoFocus(this.cameraFeatureFactory.createAutoFocusFeature(this.cameraProperties, true));
|
|
} catch (IOException e) {
|
|
this.recordingVideo = false;
|
|
this.captureFile = null;
|
|
result.error("videoRecordingFailed", e.getMessage(), null);
|
|
}
|
|
} catch (IOException | SecurityException e2) {
|
|
result.error("cannotCreateFile", e2.getMessage(), null);
|
|
}
|
|
}
|
|
|
|
private void setStreamHandler(EventChannel eventChannel) {
|
|
eventChannel.setStreamHandler(new EventChannel.StreamHandler(this) { // from class: io.flutter.plugins.camera.Camera.5
|
|
final Camera this$0;
|
|
|
|
{
|
|
this.this$0 = this;
|
|
}
|
|
|
|
@Override // io.flutter.plugin.common.EventChannel.StreamHandler
|
|
public void onListen(Object obj, EventChannel.EventSink eventSink) {
|
|
this.this$0.setImageStreamImageAvailableListener(eventSink);
|
|
}
|
|
|
|
@Override // io.flutter.plugin.common.EventChannel.StreamHandler
|
|
public void onCancel(Object obj) {
|
|
this.this$0.imageStreamReader.setOnImageAvailableListener(null, this.this$0.backgroundHandler);
|
|
}
|
|
});
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public void setImageStreamImageAvailableListener(final EventChannel.EventSink eventSink) {
|
|
this.imageStreamReader.setOnImageAvailableListener(new ImageReader.OnImageAvailableListener(this, eventSink) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda7
|
|
public final Camera f$0;
|
|
public final EventChannel.EventSink f$1;
|
|
|
|
@Override // android.media.ImageReader.OnImageAvailableListener
|
|
public final void onImageAvailable(ImageReader imageReader) {
|
|
this.f$0.m343x299dedda(this.f$1, imageReader);
|
|
}
|
|
|
|
{
|
|
this.f$0 = this;
|
|
this.f$1 = eventSink;
|
|
}
|
|
}, this.backgroundHandler);
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* renamed from: lambda$setImageStreamImageAvailableListener$17$io-flutter-plugins-camera-Camera, reason: not valid java name */
|
|
public /* synthetic */ void m343x299dedda(final EventChannel.EventSink eventSink, ImageReader imageReader) {
|
|
Image acquireNextImage = imageReader.acquireNextImage();
|
|
if (acquireNextImage == null) {
|
|
return;
|
|
}
|
|
ArrayList arrayList = new ArrayList();
|
|
for (Image.Plane plane : acquireNextImage.getPlanes()) {
|
|
ByteBuffer buffer = plane.getBuffer();
|
|
int remaining = buffer.remaining();
|
|
byte[] bArr = new byte[remaining];
|
|
buffer.get(bArr, 0, remaining);
|
|
HashMap hashMap = new HashMap();
|
|
hashMap.put("bytesPerRow", Integer.valueOf(plane.getRowStride()));
|
|
hashMap.put("bytesPerPixel", Integer.valueOf(plane.getPixelStride()));
|
|
hashMap.put("bytes", bArr);
|
|
arrayList.add(hashMap);
|
|
}
|
|
final HashMap hashMap2 = new HashMap();
|
|
hashMap2.put(RttiJsonExactionHelper.WIDTH, Integer.valueOf(acquireNextImage.getWidth()));
|
|
hashMap2.put(RttiJsonExactionHelper.HEIGHT, Integer.valueOf(acquireNextImage.getHeight()));
|
|
hashMap2.put("format", Integer.valueOf(acquireNextImage.getFormat()));
|
|
hashMap2.put("planes", arrayList);
|
|
hashMap2.put("lensAperture", this.captureProps.getLastLensAperture());
|
|
hashMap2.put("sensorExposureTime", this.captureProps.getLastSensorExposureTime());
|
|
hashMap2.put("sensorSensitivity", this.captureProps.getLastSensorSensitivity() == null ? null : Double.valueOf(r0.intValue()));
|
|
new Handler(Looper.getMainLooper()).post(new Runnable(eventSink, hashMap2) { // from class: io.flutter.plugins.camera.Camera$$ExternalSyntheticLambda16
|
|
public final EventChannel.EventSink f$0;
|
|
public final Map f$1;
|
|
|
|
@Override // java.lang.Runnable
|
|
public final void run() {
|
|
this.f$0.success(this.f$1);
|
|
}
|
|
|
|
{
|
|
this.f$0 = eventSink;
|
|
this.f$1 = hashMap2;
|
|
}
|
|
});
|
|
acquireNextImage.close();
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: private */
|
|
public void closeCaptureSession() {
|
|
CameraCaptureSession cameraCaptureSession = this.captureSession;
|
|
if (cameraCaptureSession != null) {
|
|
cameraCaptureSession.close();
|
|
this.captureSession = null;
|
|
}
|
|
}
|
|
|
|
public void close() {
|
|
CameraDeviceWrapper cameraDeviceWrapper = this.cameraDevice;
|
|
if (cameraDeviceWrapper != null) {
|
|
cameraDeviceWrapper.close();
|
|
this.cameraDevice = null;
|
|
this.captureSession = null;
|
|
} else {
|
|
closeCaptureSession();
|
|
}
|
|
ImageReader imageReader = this.pictureImageReader;
|
|
if (imageReader != null) {
|
|
imageReader.close();
|
|
this.pictureImageReader = null;
|
|
}
|
|
ImageReader imageReader2 = this.imageStreamReader;
|
|
if (imageReader2 != null) {
|
|
imageReader2.close();
|
|
this.imageStreamReader = null;
|
|
}
|
|
MediaRecorder mediaRecorder = this.mediaRecorder;
|
|
if (mediaRecorder != null) {
|
|
mediaRecorder.reset();
|
|
this.mediaRecorder.release();
|
|
this.mediaRecorder = null;
|
|
}
|
|
stopBackgroundThread();
|
|
}
|
|
|
|
public void dispose() {
|
|
close();
|
|
this.flutterTexture.release();
|
|
getDeviceOrientationManager().stop();
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* loaded from: classes6.dex */
|
|
public static class HandlerThreadFactory {
|
|
HandlerThreadFactory() {
|
|
}
|
|
|
|
public static HandlerThread create(String str) {
|
|
return new HandlerThread(str);
|
|
}
|
|
}
|
|
|
|
/* JADX INFO: Access modifiers changed from: package-private */
|
|
/* loaded from: classes6.dex */
|
|
public static class HandlerFactory {
|
|
HandlerFactory() {
|
|
}
|
|
|
|
public static Handler create(Looper looper) {
|
|
return new Handler(looper);
|
|
}
|
|
}
|
|
}
|