Added Android exposure related features

Co-authored-by: Andrew Coutts <andrewjohncoutts@gmail.com>

Author: mvanbeusekom

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/features/Point.java

@@ -0,0 +1,16 @@
+// Copyright 2013 The Flutter 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.features;
+
+/** Represents a point on an x/y axis. */
+public class Point {
+  public final Double x;
+  public final Double y;
+
+  public Point(Double x, Double y) {
+    this.x = x;
+    this.y = y;
+  }
+}

packages/camera/camera/android/src/main/java/io/flutter/plugins/camera/features/exposurelock/ExposureLockFeature.java

@@ -0,0 +1,58 @@
+// Copyright 2013 The Flutter 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.features.exposurelock;
+
+import android.hardware.camera2.CaptureRequest;
+import io.flutter.plugins.camera.CameraProperties;
+import io.flutter.plugins.camera.features.CameraFeature;
+
+/**
+ * Exposure lock controls whether or not exposure mode is currenty locked or automatically metering.
+ */
+public class ExposureLockFeature extends CameraFeature<ExposureMode> {
+  private ExposureMode currentSetting = ExposureMode.auto;
+
+  public ExposureLockFeature(CameraProperties cameraProperties) {
+    super(cameraProperties);
+  }
+
+  @Override
+  public String getDebugName() {
+    return "ExposureLockFeature";
+  }
+
+  @Override
+  public ExposureMode getValue() {
+    return currentSetting;
+  }
+
+  @Override
+  public void setValue(ExposureMode value) {
+    this.currentSetting = value;
+  }
+
+  // Available on all devices.
+  @Override
+  public boolean checkIsSupported() {
+    return true;
+  }
+
+  @Override
+  public void updateBuilder(CaptureRequest.Builder requestBuilder) {
+    if (!checkIsSupported()) {
+      return;
+    }
+
+    switch (currentSetting) {
+      case locked:
+        requestBuilder.set(CaptureRequest.CONTROL_AE_LOCK, true);
+        break;
+      case auto:
+      default:
+        requestBuilder.set(CaptureRequest.CONTROL_AE_LOCK, false);
+        break;
+    }
+  }
+}

packages/camera/camera/android/src/main/java/io/flutter/plugins/camera/features/exposurelock/ExposureMode.java

@@ -0,0 +1,29 @@
+// Copyright 2013 The Flutter 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.features.exposurelock;
+
+// Mirrors exposure_mode.dart
+public enum ExposureMode {
+  auto("auto"),
+  locked("locked");
+
+  private final String strValue;
+
+  ExposureMode(String strValue) {
+    this.strValue = strValue;
+  }
+
+  public static ExposureMode getValueForString(String modeStr) {
+    for (ExposureMode value : values()) {
+      if (value.strValue.equals(modeStr)) return value;
+    }
+    return null;
+  }
+
+  @Override
+  public String toString() {
+    return strValue;
+  }
+}

packages/camera/camera/android/src/main/java/io/flutter/plugins/camera/features/exposureoffset/ExposureOffsetFeature.java

@@ -0,0 +1,95 @@
+// Copyright 2013 The Flutter 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.features.exposureoffset;
+
+import android.hardware.camera2.CaptureRequest;
+import android.util.Range;
+import io.flutter.plugins.camera.CameraProperties;
+import io.flutter.plugins.camera.features.CameraFeature;
+
+/** Exposure offset makes the image brighter or darker. */
+public class ExposureOffsetFeature extends CameraFeature<ExposureOffsetValue> {
+  private ExposureOffsetValue currentSetting;
+  private final double min;
+  private final double max;
+
+  public ExposureOffsetFeature(CameraProperties cameraProperties) {
+    super(cameraProperties);
+
+    this.min = getMinExposureOffset();
+    this.max = getMaxExposureOffset();
+
+    // Initial offset of 0
+    this.currentSetting = new ExposureOffsetValue(this.min, this.max, 0);
+  }
+
+  @Override
+  public String getDebugName() {
+    return "ExposureOffsetFeature";
+  }
+
+  @Override
+  public ExposureOffsetValue getValue() {
+    return currentSetting;
+  }
+
+  @Override
+  public void setValue(ExposureOffsetValue value) {
+    double stepSize = getExposureOffsetStepSize();
+    this.currentSetting = new ExposureOffsetValue(min, max, (value.value / stepSize));
+  }
+
+  // Available on all devices.
+  @Override
+  public boolean checkIsSupported() {
+    return true;
+  }
+
+  @Override
+  public void updateBuilder(CaptureRequest.Builder requestBuilder) {
+    if (!checkIsSupported()) {
+      return;
+    }
+
+    requestBuilder.set(CaptureRequest.CONTROL_AE_EXPOSURE_COMPENSATION, (int) currentSetting.value);
+  }
+
+  /**
+   * Return the minimum exposure offset double value.
+   *
+   * @return
+   */
+  private double getMinExposureOffset() {
+    Range<Integer> range = cameraProperties.getControlAutoExposureCompensationRange();
+    double minStepped = range == null ? 0 : range.getLower();
+    double stepSize = getExposureOffsetStepSize();
+    return minStepped * stepSize;
+  }
+
+  /**
+   * Return the max exposure offset double value.
+   *
+   * @return
+   */
+  private double getMaxExposureOffset() {
+    Range<Integer> range = cameraProperties.getControlAutoExposureCompensationRange();
+    double maxStepped = range == null ? 0 : range.getUpper();
+    double stepSize = getExposureOffsetStepSize();
+    return maxStepped * stepSize;
+  }
+
+  /**
+   * Returns the exposure offset step size. This is the smallest amount which the exposure offset
+   * can be changed.
+   *
+   * <p>Example: if this has a value of 0.5, then an aeExposureCompensation setting of -2 means that
+   * the actual AE offset is -1.
+   *
+   * @return
+   */
+  public double getExposureOffsetStepSize() {
+    return cameraProperties.getControlAutoExposureCompensationStep();
+  }
+}

packages/camera/camera/android/src/main/java/io/flutter/plugins/camera/features/exposureoffset/ExposureOffsetValue.java

@@ -0,0 +1,25 @@
+// Copyright 2013 The Flutter 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.features.exposureoffset;
+
+/**
+ * This represents the exposure offset value. It holds the minimum and maximum values, as well as
+ * the current setting value.
+ */
+public class ExposureOffsetValue {
+  public final double min;
+  public final double max;
+  public final double value;
+
+  public ExposureOffsetValue(double min, double max, double value) {
+    this.min = min;
+    this.max = max;
+    this.value = value;
+  }
+
+  public ExposureOffsetValue(double value) {
+    this(0, 0, value);
+  }
+}

packages/camera/camera/android/src/main/java/io/flutter/plugins/camera/features/exposurepoint/ExposurePointFeature.java

@@ -0,0 +1,77 @@
+// Copyright 2013 The Flutter 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.features.exposurepoint;
+
+import android.hardware.camera2.CaptureRequest;
+import android.hardware.camera2.params.MeteringRectangle;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import io.flutter.plugins.camera.CameraProperties;
+import io.flutter.plugins.camera.features.CameraFeature;
+import io.flutter.plugins.camera.features.Point;
+import io.flutter.plugins.camera.features.regionboundaries.CameraRegions;
+import java.util.concurrent.Callable;
+
+/** Exposure point controls where in the frame exposure metering will come from. */
+public class ExposurePointFeature extends CameraFeature<Point> {
+  // Used later to always get the correct camera regions instance.
+  private final Callable<CameraRegions> getCameraRegions;
+  private Point currentSetting = new Point(0.0, 0.0);
+
+  public ExposurePointFeature(
+      CameraProperties cameraProperties, Callable<CameraRegions> getCameraRegions) {
+    super(cameraProperties);
+    this.getCameraRegions = getCameraRegions;
+  }
+
+  @Override
+  public String getDebugName() {
+    return "ExposurePointFeature";
+  }
+
+  @Override
+  public Point getValue() {
+    return currentSetting;
+  }
+
+  @Override
+  public void setValue(@NonNull Point value) {
+    this.currentSetting = value;
+
+    try {
+      if (value.x == null || value.y == null) {
+        getCameraRegions.call().resetAutoExposureMeteringRectangle();
+      } else {
+        getCameraRegions.call().setAutoExposureMeteringRectangleFromPoint(value.x, value.y);
+      }
+    } catch (Exception e) {
+      e.printStackTrace();
+    }
+  }
+
+  // Whether or not this camera can set the exposure point.
+  @Override
+  public boolean checkIsSupported() {
+    Integer supportedRegions = cameraProperties.getControlMaxRegionsAutoExposure();
+    return supportedRegions != null && supportedRegions > 0;
+  }
+
+  @Override
+  public void updateBuilder(CaptureRequest.Builder requestBuilder) {
+    if (!checkIsSupported()) {
+      return;
+    }
+
+    MeteringRectangle aeRect;
+    try {
+      aeRect = getCameraRegions.call().getAEMeteringRectangle();
+      requestBuilder.set(
+          CaptureRequest.CONTROL_AE_REGIONS,
+          aeRect == null ? null : new MeteringRectangle[] {aeRect});
+    } catch (Exception e) {
+      Log.w("Camera", "Unable to retrieve the Auto Exposure metering rectangle.", e);
+    }
+  }
+}

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

@@ -0,0 +1,77 @@
+// Copyright 2013 The Flutter 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.features.regionboundaries;
+
+import android.hardware.camera2.params.MeteringRectangle;
+import android.util.Size;
+
+public final class CameraRegions {
+  private final Size maxBoundaries;
+
+  private MeteringRectangle aeMeteringRectangle;
+  private MeteringRectangle afMeteringRectangle;
+
+  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 MeteringRectangle getAFMeteringRectangle() {
+    return afMeteringRectangle;
+  }
+
+  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 void resetAutoFocusMeteringRectangle() {
+    this.afMeteringRectangle = null;
+  }
+
+  public void setAutoFocusMeteringRectangleFromPoint(double x, double y) {
+    this.afMeteringRectangle = 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);
+  }
+}