[camera] Fix all capture timeout, autofocus, flash, exposure, and device crash issues

packages/camera/camera/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.8.1
+
+* Complete rewrite of Android plugin to fix all capture, focus, flash, and exposure issues.
+* Fixed crash when opening front-facing cameras on some legacy android devices like Sony XZ.
+* Android Flash mode works with full precapture sequence.
+
 ## 0.8.0
 
 * Stable null safety release.

packages/camera/camera/android/build.gradle

@@ -49,7 +49,7 @@ android {
 dependencies {
     compileOnly 'androidx.annotation:annotation:1.1.0'
     testImplementation 'junit:junit:4.12'
-    testImplementation 'org.mockito:mockito-core:3.5.13'
+    testImplementation 'org.mockito:mockito-inline:3.5.13'
     testImplementation 'androidx.test:core:1.3.0'
     testImplementation 'org.robolectric:robolectric:4.3'
 }

packages/camera/camera/android/src/main/java/io/flutter/plugins/camera/CameraCaptureCallback.java

@@ -0,0 +1,144 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package io.flutter.plugins.camera;
+
+import android.hardware.camera2.CameraCaptureSession;
+import android.hardware.camera2.CameraCaptureSession.CaptureCallback;
+import android.hardware.camera2.CaptureRequest;
+import android.hardware.camera2.CaptureResult;
+import android.hardware.camera2.TotalCaptureResult;
+import android.util.Log;
+import androidx.annotation.NonNull;
+
+class CameraCaptureCallback extends CaptureCallback {
+  private final CameraCaptureStateListener cameraStateListener;
+  private CameraState cameraState;
+  private PictureCaptureRequest pictureCaptureRequest;
+
+  private CameraCaptureCallback(@NonNull CameraCaptureStateListener cameraStateListener) {
+    cameraState = CameraState.STATE_PREVIEW;
+    this.cameraStateListener = cameraStateListener;
+  }
+
+  public static CameraCaptureCallback create(
+      @NonNull CameraCaptureStateListener cameraStateListener) {
+    return new CameraCaptureCallback(cameraStateListener);
+  }
+
+  public CameraState getCameraState() {
+    return cameraState;
+  }
+
+  public void setCameraState(@NonNull CameraState state) {
+    cameraState = state;
+  }
+
+  public void setPictureCaptureRequest(@NonNull PictureCaptureRequest pictureCaptureRequest) {
+    this.pictureCaptureRequest = pictureCaptureRequest;
+  }
+
+  private void process(CaptureResult result) {
+    Integer aeState = result.get(CaptureResult.CONTROL_AE_STATE);
+    Integer afState = result.get(CaptureResult.CONTROL_AF_STATE);
+
+    if (cameraState != CameraState.STATE_PREVIEW) {
+      Log.i(
+          "Camera",
+          "CameraCaptureCallback | state: "
+              + cameraState
+              + " | afState: "
+              + afState
+              + " | aeState: "
+              + aeState);
+    }
+
+    switch (cameraState) {
+      case STATE_PREVIEW:
+        {
+          // We have nothing to do when the camera preview is working normally.
+          break;
+        }
+      case STATE_WAITING_FOCUS:
+        {
+          if (afState == null) {
+            return;
+          } else if (afState == CaptureResult.CONTROL_AF_STATE_FOCUSED_LOCKED
+              || afState == CaptureResult.CONTROL_AF_STATE_NOT_FOCUSED_LOCKED) {
+            handleWaitingFocusState(aeState);
+          } else if (pictureCaptureRequest != null
+              && pictureCaptureRequest.preCaptureFocusing.getIsExpired()) {
+            Log.w("Camera", "Focus timeout, moving on with capture");
+            handleWaitingFocusState(aeState);
+          }
+
+          break;
+        }
+      case STATE_WAITING_PRECAPTURE_START:
+        {
+          // CONTROL_AE_STATE can be null on some devices
+          if (aeState == null
+              || aeState == CaptureResult.CONTROL_AE_STATE_CONVERGED
+              || aeState == CaptureResult.CONTROL_AE_STATE_PRECAPTURE
+              || aeState == CaptureResult.CONTROL_AE_STATE_FLASH_REQUIRED) {
+            setCameraState(CameraState.STATE_WAITING_PRECAPTURE_DONE);
+          } else if (pictureCaptureRequest != null
+              && pictureCaptureRequest.preCaptureMetering.getIsExpired()) {
+            Log.w(
+                "Camera",
+                "Metering timeout waiting for pre-capture to start, moving on with capture");
+
+            setCameraState(CameraState.STATE_WAITING_PRECAPTURE_DONE);
+          }
+          break;
+        }
+      case STATE_WAITING_PRECAPTURE_DONE:
+        {
+          // CONTROL_AE_STATE can be null on some devices
+          if (aeState == null || aeState != CaptureResult.CONTROL_AE_STATE_PRECAPTURE) {
+            cameraStateListener.onConverged();
+          } else if (pictureCaptureRequest != null
+              && pictureCaptureRequest.preCaptureMetering.getIsExpired()) {
+            Log.w(
+                "Camera",
+                "Metering timeout waiting for pre-capture to finish, moving on with capture");
+            cameraStateListener.onConverged();
+          }
+
+          break;
+        }
+    }
+  }
+
+  private void handleWaitingFocusState(Integer aeState) {
+    // CONTROL_AE_STATE can be null on some devices
+    if (aeState == null || aeState == CaptureRequest.CONTROL_AE_STATE_CONVERGED) {
+      cameraStateListener.onConverged();
+    } else {
+      cameraStateListener.onPrecapture();
+    }
+  }
+
+  @Override
+  public void onCaptureProgressed(
+      @NonNull CameraCaptureSession session,
+      @NonNull CaptureRequest request,
+      @NonNull CaptureResult partialResult) {
+    process(partialResult);
+  }
+
+  @Override
+  public void onCaptureCompleted(
+      @NonNull CameraCaptureSession session,
+      @NonNull CaptureRequest request,
+      @NonNull TotalCaptureResult result) {
+    process(result);
+  }
+
+  interface CameraCaptureStateListener {
+    void onConverged();
+
+    void onPrecapture();
+  }
+}

packages/camera/camera/android/src/main/java/io/flutter/plugins/camera/CameraPlugin.java

@@ -26,7 +26,7 @@
  */
 public final class CameraPlugin implements FlutterPlugin, ActivityAware {
 
-  private static final String TAG = "CameraPlugin";
+  // private static final String TAG = "CameraPlugin";
   private @Nullable FlutterPluginBinding flutterPluginBinding;
   private @Nullable MethodCallHandlerImpl methodCallHandler;
 

packages/camera/camera/android/src/main/java/io/flutter/plugins/camera/CameraProperties.java

@@ -0,0 +1,166 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package io.flutter.plugins.camera;
+
+import android.graphics.Rect;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraManager;
+import android.os.Build.VERSION_CODES;
+import android.util.Range;
+import android.util.Rational;
+import android.util.Size;
+import androidx.annotation.RequiresApi;
+
+public interface CameraProperties {
+  String getCameraName();
+
+  Range<Integer>[] getControlAutoExposureAvailableTargetFpsRanges();
+
+  Range<Integer> getControlAutoExposureCompensationRange();
+
+  double getControlAutoExposureCompensationStep();
+
+  int[] getControlAutoFocusAvailableModes();
+
+  Integer getControlMaxRegionsAutoExposure();
+
+  Integer getControlMaxRegionsAutoFocus();
+
+  int[] getDistortionCorrectionAvailableModes();
+
+  Boolean getFlashInfoAvailable();
+
+  int getLensFacing();
+
+  Float getLensInfoMinimumFocusDistance();
+
+  Float getScalerAvailableMaxDigitalZoom();
+
+  Rect getSensorInfoActiveArraySize();
+
+  Size getSensorInfoPixelArraySize();
+
+  Rect getSensorInfoPreCorrectionActiveArraySize();
+
+  int getSensorOrientation();
+
+  int getHardwareLevel();
+
+  int[] getAvailableNoiseReductionModes();
+}
+
+class CameraPropertiesImpl implements CameraProperties {
+  private final CameraCharacteristics cameraCharacteristics;
+  private final String cameraName;
+
+  public CameraPropertiesImpl(String cameraName, CameraManager cameraManager)
+      throws CameraAccessException {
+    this.cameraName = cameraName;
+    this.cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraName);
+  }
+
+  @Override
+  public String getCameraName() {
+    return cameraName;
+  }
+
+  @Override
+  public Range<Integer>[] getControlAutoExposureAvailableTargetFpsRanges() {
+    return cameraCharacteristics.get(CameraCharacteristics.CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES);
+  }
+
+  @Override
+  public Range<Integer> getControlAutoExposureCompensationRange() {
+    return cameraCharacteristics.get(CameraCharacteristics.CONTROL_AE_COMPENSATION_RANGE);
+  }
+
+  @Override
+  public double getControlAutoExposureCompensationStep() {
+    Rational rational =
+        cameraCharacteristics.get(CameraCharacteristics.CONTROL_AE_COMPENSATION_STEP);
+
+    return rational == null ? 0.0 : rational.doubleValue();
+  }
+
+  @Override
+  public int[] getControlAutoFocusAvailableModes() {
+    return cameraCharacteristics.get(CameraCharacteristics.CONTROL_AF_AVAILABLE_MODES);
+  }
+
+  @Override
+  public Integer getControlMaxRegionsAutoExposure() {
+    return cameraCharacteristics.get(CameraCharacteristics.CONTROL_MAX_REGIONS_AE);
+  }
+
+  @Override
+  public Integer getControlMaxRegionsAutoFocus() {
+    return cameraCharacteristics.get(CameraCharacteristics.CONTROL_MAX_REGIONS_AF);
+  }
+
+  @RequiresApi(api = VERSION_CODES.P)
+  @Override
+  public int[] getDistortionCorrectionAvailableModes() {
+    return cameraCharacteristics.get(CameraCharacteristics.DISTORTION_CORRECTION_AVAILABLE_MODES);
+  }
+
+  @Override
+  public Boolean getFlashInfoAvailable() {
+    return cameraCharacteristics.get(CameraCharacteristics.FLASH_INFO_AVAILABLE);
+  }
+
+  @Override
+  public int getLensFacing() {
+    return cameraCharacteristics.get(CameraCharacteristics.LENS_FACING);
+  }
+
+  @Override
+  public Float getLensInfoMinimumFocusDistance() {
+    return cameraCharacteristics.get(CameraCharacteristics.LENS_INFO_MINIMUM_FOCUS_DISTANCE);
+  }
+
+  @Override
+  public Float getScalerAvailableMaxDigitalZoom() {
+    return cameraCharacteristics.get(CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM);
+  }
+
+  @Override
+  public Rect getSensorInfoActiveArraySize() {
+    return cameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
+  }
+
+  @Override
+  public Size getSensorInfoPixelArraySize() {
+    return cameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_PIXEL_ARRAY_SIZE);
+  }
+
+  @RequiresApi(api = VERSION_CODES.M)
+  @Override
+  public Rect getSensorInfoPreCorrectionActiveArraySize() {
+    return cameraCharacteristics.get(
+        CameraCharacteristics.SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
+  }
+
+  @Override
+  public int getSensorOrientation() {
+    return cameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION);
+  }
+
+  /**
+   * Returns the hardware level of the camera.
+   *
+   * @return
+   */
+  @Override
+  public int getHardwareLevel() {
+    return cameraCharacteristics.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
+  }
+
+  @Override
+  public int[] getAvailableNoiseReductionModes() {
+    return cameraCharacteristics.get(
+        CameraCharacteristics.NOISE_REDUCTION_AVAILABLE_NOISE_REDUCTION_MODES);
+  }
+}

packages/camera/camera/android/src/main/java/io/flutter/plugins/camera/CameraState.java

@@ -0,0 +1,27 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package io.flutter.plugins.camera;
+
+/**
+ * These are the states that the camera can be in. The camera can only take one photo at a time so
+ * this state describes the state of the camera itself. The camera works like a pipeline where we
+ * feed it requests through. It can only process one tasks at a time.
+ */
+public enum CameraState {
+  /** Idle, showing preview and not capturing anything. */
+  STATE_PREVIEW,
+
+  /** Starting and waiting for autofocus to complete. */
+  STATE_WAITING_FOCUS,
+
+  /** Start performing autoexposure. */
+  STATE_WAITING_PRECAPTURE_START,
+
+  /** waiting for autoexposure to complete. */
+  STATE_WAITING_PRECAPTURE_DONE,
+
+  /** Capturing an image. */
+  STATE_CAPTURING,
+}