[camera] Add iOS and Android implementations for managing auto exposure. (flutter#3346)

* Added platform interface methods for setting auto exposure.

* Added platform interface methods for setting auto exposure.

* Remove workspace files

* Added auto exposure implementations for Android and iOS

* iOS fix for setting the exposure point

* Removed unnecessary check

* Update platform interface dependency

* Implement PR feedback

* Restore test

* Small improvements for exposure point resetting

Author: BeMacized

packages/camera/camera/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.6.4
+
+* Adds auto exposure support for Android and iOS implementations.
+
 ## 0.6.3+4
 
 * Revert previous dependency update: Changed dependency on camera_platform_interface to >=1.04 <1.1.0.

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

@@ -144,6 +144,7 @@ public void onOrientationChanged(int i) {
             characteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE),
             characteristics.get(CameraCharacteristics.SCALER_AVAILABLE_MAX_DIGITAL_ZOOM));
   }
+  private CameraRegions cameraRegions;
 
   private void prepareMediaRecorder(String outputFilePath) throws IOException {
     if (mediaRecorder != null) {
@@ -175,6 +176,7 @@ public void open() throws CameraAccessException {
           public void onOpened(@NonNull CameraDevice device) {
             cameraDevice = device;
             try {
+              cameraRegions = new CameraRegions(getRegionBoundaries());
               startPreview();
               dartMessenger.sendCameraInitializedEvent(
                   previewSize.getWidth(),
@@ -639,7 +641,7 @@ public void setFlashMode(@NonNull final Result result, FlashMode mode)
     // If switching directly from torch to auto or on, make sure we turn off the torch.
     if (flashMode == FlashMode.torch && mode != FlashMode.torch && mode != FlashMode.off) {
       this.flashMode = FlashMode.off;
-    initPreviewCaptureBuilder();
+      initPreviewCaptureBuilder();
       this.cameraCaptureSession.setRepeatingRequest(
           captureRequestBuilder.build(),
           new CaptureCallback() {
@@ -675,8 +677,8 @@ public void onCaptureFailed(
           null);
     } else {
       updateFlash(mode);
-    result.success(null);
-  }
+      result.success(null);
+    }
   }
 
   public void setWbMode(@NonNull final Result result, WbMode mode)
@@ -906,9 +908,11 @@ private void initPreviewCaptureBuilder() {
         break;
     }
 
+
     // Applying auto exposure
     if (aeMeteringRectangle != null) {
-      captureRequestBuilder.set(
+    captureRequestBuilder.set(
+
           CaptureRequest.CONTROL_AE_REGIONS, new MeteringRectangle[] {aeMeteringRectangle});
   }
     switch (exposureMode) {
@@ -972,7 +976,7 @@ private void initPreviewCaptureBuilder() {
         captureRequestBuilder.set(CaptureRequest.CONTROL_AWB_MODE, CameraMetadata.CONTROL_AWB_MODE_AUTO);
         //captureRequestBuilder.set(CaptureRequest.CONTROL_AWB_LOCK, false);
         break;
-    }
+  }
   }
 
   public void startPreview() throws CameraAccessException {
@@ -999,6 +1003,47 @@ public void onCancel(Object o) {
         });
   }
 
+  @TargetApi(VERSION_CODES.P)
+  private boolean supportsDistortionCorrection() throws CameraAccessException {
+    int[] availableDistortionCorrectionModes =
+        cameraManager
+            .getCameraCharacteristics(cameraDevice.getId())
+            .get(CameraCharacteristics.DISTORTION_CORRECTION_AVAILABLE_MODES);
+    if (availableDistortionCorrectionModes == null) availableDistortionCorrectionModes = new int[0];
+    long nonOffModesSupported =
+        Arrays.stream(availableDistortionCorrectionModes)
+            .filter((value) -> value != CaptureRequest.DISTORTION_CORRECTION_MODE_OFF)
+            .count();
+    return nonOffModesSupported > 0;
+  }
+
+  private Size getRegionBoundaries() throws CameraAccessException {
+    // No distortion correction support
+    if (android.os.Build.VERSION.SDK_INT < VERSION_CODES.P || !supportsDistortionCorrection()) {
+      return cameraManager
+          .getCameraCharacteristics(cameraDevice.getId())
+          .get(CameraCharacteristics.SENSOR_INFO_PIXEL_ARRAY_SIZE);
+    }
+    // Get the current distortion correction mode
+    Integer distortionCorrectionMode =
+        captureRequestBuilder.get(CaptureRequest.DISTORTION_CORRECTION_MODE);
+    // Return the correct boundaries depending on the mode
+    android.graphics.Rect rect;
+    if (distortionCorrectionMode == null
+        || distortionCorrectionMode == CaptureRequest.DISTORTION_CORRECTION_MODE_OFF) {
+      rect =
+          cameraManager
+              .getCameraCharacteristics(cameraDevice.getId())
+              .get(CameraCharacteristics.SENSOR_INFO_PRE_CORRECTION_ACTIVE_ARRAY_SIZE);
+    } else {
+      rect =
+          cameraManager
+              .getCameraCharacteristics(cameraDevice.getId())
+              .get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE);
+    }
+    return rect == null ? null : new Size(rect.width(), rect.height());
+  }
+
   private void setImageStreamImageAvailableListener(final EventChannel.EventSink imageStreamSink) {
     imageStreamReader.setOnImageAvailableListener(
         reader -> {

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

@@ -0,0 +1,59 @@
+package io.flutter.plugins.camera;
+
+import android.hardware.camera2.params.MeteringRectangle;
+import android.util.Size;
+
+public final class CameraRegions {
+  private MeteringRectangle aeMeteringRectangle;
+  private Size maxBoundaries;
+
+  public CameraRegions(Size maxBoundaries) {
+    assert (maxBoundaries == null || maxBoundaries.getWidth() > 0);
+    assert (maxBoundaries == null || maxBoundaries.getHeight() > 0);
+    this.maxBoundaries = maxBoundaries;
+  }
+
+  public MeteringRectangle getAEMeteringRectangle() {
+    return aeMeteringRectangle;
+  }
+
+  public Size getMaxBoundaries() {
+    return this.maxBoundaries;
+  }
+
+  public void resetAutoExposureMeteringRectangle() {
+    this.aeMeteringRectangle = null;
+  }
+
+  public void setAutoExposureMeteringRectangleFromPoint(double x, double y) {
+    this.aeMeteringRectangle = getMeteringRectangleForPoint(maxBoundaries, x, y);
+  }
+
+  public MeteringRectangle getMeteringRectangleForPoint(Size maxBoundaries, double x, double y) {
+    assert (x >= 0 && x <= 1);
+    assert (y >= 0 && y <= 1);
+    if (maxBoundaries == null)
+      throw new IllegalStateException(
+          "Functionality for managing metering rectangles is unavailable as this CameraRegions instance was initialized with null boundaries.");
+
+    // Interpolate the target coordinate
+    int targetX = (int) Math.round(x * ((double) (maxBoundaries.getWidth() - 1)));
+    int targetY = (int) Math.round(y * ((double) (maxBoundaries.getHeight() - 1)));
+    // Determine the dimensions of the metering triangle (10th of the viewport)
+    int targetWidth = (int) Math.round(((double) maxBoundaries.getWidth()) / 10d);
+    int targetHeight = (int) Math.round(((double) maxBoundaries.getHeight()) / 10d);
+    // Adjust target coordinate to represent top-left corner of metering rectangle
+    targetX -= targetWidth / 2;
+    targetY -= targetHeight / 2;
+    // Adjust target coordinate as to not fall out of bounds
+    if (targetX < 0) targetX = 0;
+    if (targetY < 0) targetY = 0;
+    int maxTargetX = maxBoundaries.getWidth() - 1 - targetWidth;
+    int maxTargetY = maxBoundaries.getHeight() - 1 - targetHeight;
+    if (targetX > maxTargetX) targetX = maxTargetX;
+    if (targetY > maxTargetY) targetY = maxTargetY;
+
+    // Build the metering rectangle
+    return new MeteringRectangle(targetX, targetY, targetWidth, targetHeight, 1);
+  }
+}

packages/camera/camera/android/src/test/java/io/flutter/plugins/camera/CameraRegionsTest.java

@@ -0,0 +1,105 @@
+package io.flutter.plugins.camera;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+import android.hardware.camera2.params.MeteringRectangle;
+import android.util.Size;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public class CameraRegionsTest {
+
+  CameraRegions cameraRegions;
+
+  @Before
+  public void setUp() {
+    this.cameraRegions = new CameraRegions(new Size(100, 50));
+  }
+
+  @Test(expected = AssertionError.class)
+  public void getMeteringRectangleForPoint_should_throw_for_x_upper_bound() {
+    cameraRegions.getMeteringRectangleForPoint(new Size(10, 10), 1.5, 0);
+  }
+
+  @Test(expected = AssertionError.class)
+  public void getMeteringRectangleForPoint_should_throw_for_x_lower_bound() {
+    cameraRegions.getMeteringRectangleForPoint(new Size(10, 10), -0.5, 0);
+  }
+
+  @Test(expected = AssertionError.class)
+  public void getMeteringRectangleForPoint_should_throw_for_y_upper_bound() {
+    cameraRegions.getMeteringRectangleForPoint(new Size(10, 10), 0, 1.5);
+  }
+
+  @Test(expected = AssertionError.class)
+  public void getMeteringRectangleForPoint_should_throw_for_y_lower_bound() {
+    cameraRegions.getMeteringRectangleForPoint(new Size(10, 10), 0, -0.5);
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void getMeteringRectangleForPoint_should_throw_for_null_boundaries() {
+    cameraRegions.getMeteringRectangleForPoint(null, 0, -0);
+  }
+
+  @Test
+  public void getMeteringRectangleForPoint_should_return_valid_MeteringRectangle() {
+    MeteringRectangle r;
+    // Center
+    r = cameraRegions.getMeteringRectangleForPoint(cameraRegions.getMaxBoundaries(), 0.5, 0.5);
+    assertEquals(new MeteringRectangle(45, 23, 10, 5, 1), r);
+
+    // Top left
+    r = cameraRegions.getMeteringRectangleForPoint(cameraRegions.getMaxBoundaries(), 0.0, 0.0);
+    assertEquals(new MeteringRectangle(0, 0, 10, 5, 1), r);
+
+    // Bottom right
+    r = cameraRegions.getMeteringRectangleForPoint(cameraRegions.getMaxBoundaries(), 1.0, 1.0);
+    assertEquals(new MeteringRectangle(89, 44, 10, 5, 1), r);
+
+    // Top left
+    r = cameraRegions.getMeteringRectangleForPoint(cameraRegions.getMaxBoundaries(), 0.0, 1.0);
+    assertEquals(new MeteringRectangle(0, 44, 10, 5, 1), r);
+
+    // Top right
+    r = cameraRegions.getMeteringRectangleForPoint(cameraRegions.getMaxBoundaries(), 1.0, 0.0);
+    assertEquals(new MeteringRectangle(89, 0, 10, 5, 1), r);
+  }
+
+  @Test(expected = AssertionError.class)
+  public void constructor_should_throw_for_0_width_boundary() {
+    new CameraRegions(new Size(0, 50));
+  }
+
+  @Test(expected = AssertionError.class)
+  public void constructor_should_throw_for_0_height_boundary() {
+    new CameraRegions(new Size(100, 0));
+  }
+
+  @Test
+  public void constructor_should_initialize() {
+    CameraRegions cr = new CameraRegions(new Size(100, 50));
+    assertEquals(new Size(100, 50), cr.getMaxBoundaries());
+    assertNull(cr.getAEMeteringRectangle());
+  }
+
+  @Test
+  public void setAutoExposureMeteringRectangleFromPoint_should_set_aeMeteringRectangle_for_point() {
+    CameraRegions cr = new CameraRegions(new Size(100, 50));
+    cr.setAutoExposureMeteringRectangleFromPoint(0, 0);
+    assertEquals(new MeteringRectangle(0, 0, 10, 5, 1), cr.getAEMeteringRectangle());
+  }
+
+  @Test
+  public void resetAutoExposureMeteringRectangle_should_reset_aeMeteringRectangle() {
+    CameraRegions cr = new CameraRegions(new Size(100, 50));
+    cr.setAutoExposureMeteringRectangleFromPoint(0, 0);
+    assertNotNull(cr.getAEMeteringRectangle());
+    cr.resetAutoExposureMeteringRectangle();
+    assertNull(cr.getAEMeteringRectangle());
+  }
+}