[camera] Add Android & iOS implementations for pausing the camera preview

packages/camera/camera/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.9.0
+
+* Complete rewrite of Android plugin to fix many capture, focus, flash, orientation 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.1+4
 
 * Silenced warnings that may occur during build when using a very

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

@@ -32,7 +32,6 @@
 import android.os.Looper;
 import android.util.Log;
 import android.util.Size;
-import android.util.SparseIntArray;
 import android.view.Display;
 import android.view.Surface;
 import androidx.annotation.NonNull;
@@ -95,18 +94,8 @@ interface ErrorCallback {
 class Camera implements CameraCaptureCallback.CameraCaptureStateListener {
   private static final String TAG = "Camera";
 
-  /** Conversion from screen rotation to JPEG orientation. */
-  private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
-
   private static final HashMap<String, Integer> supportedImageFormats;
 
-  static {
-    ORIENTATIONS.append(Surface.ROTATION_0, 90);
-    ORIENTATIONS.append(Surface.ROTATION_90, 0);
-    ORIENTATIONS.append(Surface.ROTATION_180, 270);
-    ORIENTATIONS.append(Surface.ROTATION_270, 180);
-  }
-
   // Current supported outputs
   static {
     supportedImageFormats = new HashMap<>();
@@ -209,20 +198,23 @@ public Camera(
         cameraFeatureFactory.createExposureLockFeature(cameraProperties));
     this.cameraFeatures.setExposureOffset(
         cameraFeatureFactory.createExposureOffsetFeature(cameraProperties));
+    SensorOrientationFeature sensorOrientationFeature =
+        cameraFeatureFactory.createSensorOrientationFeature(
+            cameraProperties, activity, dartMessenger);
+    this.cameraFeatures.setSensorOrientation(sensorOrientationFeature);
     this.cameraFeatures.setExposurePoint(
-        cameraFeatureFactory.createExposurePointFeature(cameraProperties));
+        cameraFeatureFactory.createExposurePointFeature(
+            cameraProperties, sensorOrientationFeature));
     this.cameraFeatures.setFlash(cameraFeatureFactory.createFlashFeature(cameraProperties));
     this.cameraFeatures.setFocusPoint(
-        cameraFeatureFactory.createFocusPointFeature(cameraProperties));
+        cameraFeatureFactory.createFocusPointFeature(cameraProperties, sensorOrientationFeature));
     this.cameraFeatures.setFpsRange(cameraFeatureFactory.createFpsRangeFeature(cameraProperties));
     this.cameraFeatures.setNoiseReduction(
         cameraFeatureFactory.createNoiseReductionFeature(cameraProperties));
     this.cameraFeatures.setResolution(
         cameraFeatureFactory.createResolutionFeature(
             cameraProperties, resolutionPreset, cameraProperties.getCameraName()));
-    this.cameraFeatures.setSensorOrientation(
-        cameraFeatureFactory.createSensorOrientationFeature(
-            cameraProperties, activity, dartMessenger));
+
     this.cameraFeatures.setZoomLevel(cameraFeatureFactory.createZoomLevelFeature(cameraProperties));
 
     // Create capture callback
@@ -271,8 +263,8 @@ private void prepareMediaRecorder(String outputFilePath) throws IOException {
             .setEnableAudio(enableAudio)
             .setMediaOrientation(
                 lockedOrientation == null
-                    ? getDeviceOrientationManager().getMediaOrientation()
-                    : getDeviceOrientationManager().getMediaOrientation(lockedOrientation))
+                    ? getDeviceOrientationManager().getVideoOrientation()
+                    : getDeviceOrientationManager().getVideoOrientation(lockedOrientation))
             .build();
   }
 
@@ -596,8 +588,14 @@ private void takePictureAfterPrecapture() {
       updateBuilderSettings(stillBuilder);
 
       // Orientation
-      int rotation = getDefaultDisplay().getRotation();
-      stillBuilder.set(CaptureRequest.JPEG_ORIENTATION, getOrientation(rotation));
+      final PlatformChannel.DeviceOrientation lockedOrientation =
+          ((SensorOrientationFeature) cameraFeatures.getSensorOrientation())
+              .getLockedCaptureOrientation();
+      stillBuilder.set(
+          CaptureRequest.JPEG_ORIENTATION,
+          lockedOrientation == null
+              ? getDeviceOrientationManager().getPhotoOrientation()
+              : getDeviceOrientationManager().getPhotoOrientation(lockedOrientation));
 
       CameraCaptureSession.CaptureCallback captureCallback =
           new CameraCaptureSession.CaptureCallback() {
@@ -665,21 +663,6 @@ private void stopBackgroundThread() {
     }
   }
 
-  /**
-   * Retrieves the JPEG orientation from the specified screen rotation.
-   *
-   * @param rotation The screen rotation.
-   * @return The JPEG orientation (one of 0, 90, 270, and 360)
-   */
-  private int getOrientation(int rotation) {
-    // Sensor orientation is 90 for most devices, or 270 for some devices (eg. Nexus 5X)
-    // We have to take that into account and rotate JPEG properly.
-    // For devices with orientation of 90, we simply return our mapping from ORIENTATIONS.
-    // For devices with orientation of 270, we need to rotate the JPEG 180 degrees.
-    final Integer sensorOrientation = cameraFeatures.getSensorOrientation().getValue();
-    return (ORIENTATIONS.get(rotation) + sensorOrientation + 270) % 360;
-  }
-
   /** Start capturing a picture, doing autofocus first. */
   private void runPictureAutoFocus() {
     Log.i(TAG, "runPictureAutoFocus");
@@ -908,7 +891,7 @@ public double getExposureOffsetStepSize() {
    * @param result Flutter result.
    * @param newMode New mode.
    */
-  public void setFocusMode(@NonNull final Result result, FocusMode newMode) {
+  public void setFocusMode(final Result result, FocusMode newMode) {
     final AutoFocusFeature autoFocusFeature = cameraFeatures.getAutoFocus();
     autoFocusFeature.setValue(newMode);
     autoFocusFeature.updateBuilder(previewRequestBuilder);
@@ -930,7 +913,9 @@ public void setFocusMode(@NonNull final Result result, FocusMode newMode) {
           captureSession.setRepeatingRequest(
               previewRequestBuilder.build(), null, backgroundHandler);
         } catch (CameraAccessException e) {
-          result.error("setFocusModeFailed", "Error setting focus mode: " + e.getMessage(), null);
+          if (result != null) {
+            result.error("setFocusModeFailed", "Error setting focus mode: " + e.getMessage(), null);
+          }
         }
         break;
 
@@ -940,7 +925,9 @@ public void setFocusMode(@NonNull final Result result, FocusMode newMode) {
         break;
     }
 
-    result.success(null);
+    if (result != null) {
+      result.success(null);
+    }
   }
 
   /**
@@ -957,6 +944,8 @@ public void setFocusPoint(@NonNull final Result result, Point point) {
     refreshPreviewCaptureSession(
         () -> result.success(null),
         (code, message) -> result.error("setFocusPointFailed", "Could not set focus point.", null));
+
+    this.setFocusMode(null, cameraFeatures.getAutoFocus().getValue());
   }
 
   /**

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

@@ -11,6 +11,7 @@
 import android.util.Size;
 import androidx.annotation.NonNull;
 import androidx.annotation.VisibleForTesting;
+import io.flutter.embedding.engine.systemchannels.PlatformChannel;
 import java.util.Arrays;
 
 /**
@@ -69,11 +70,32 @@ && supportsDistortionCorrection(cameraProperties)) {
    *     boundaries.
    */
   public static MeteringRectangle convertPointToMeteringRectangle(
-      @NonNull Size boundaries, double x, double y) {
+      @NonNull Size boundaries,
+      double x,
+      double y,
+      @NonNull PlatformChannel.DeviceOrientation orientation) {
     assert (boundaries.getWidth() > 0 && boundaries.getHeight() > 0);
     assert (x >= 0 && x <= 1);
     assert (y >= 0 && y <= 1);
-
+    // Rotate the coordinates to match the device orientation
+    double oldX = x, oldY = y;
+    switch (orientation) {
+      case PORTRAIT_UP: // 90 ccw
+        y = 1 - oldX;
+        x = oldY;
+        break;
+      case PORTRAIT_DOWN: // 90 cw
+        x = 1 - oldY;
+        y = oldX;
+        break;
+      case LANDSCAPE_LEFT:
+        // No rotation required
+        break;
+      case LANDSCAPE_RIGHT: // 180
+        x = 1 - x;
+        y = 1 - y;
+        break;
+    }
     // Interpolate the target coordinate.
     int targetX = (int) Math.round(x * ((double) (boundaries.getWidth() - 1)));
     int targetY = (int) Math.round(y * ((double) (boundaries.getHeight() - 1)));

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

@@ -84,9 +84,13 @@ ResolutionFeature createResolutionFeature(
    *
    * @param cameraProperties instance of the CameraProperties class containing information about the
    *     cameras features.
+   * @param sensorOrientationFeature instance of the SensorOrientationFeature class containing
+   *     information about the sensor and device orientation.
    * @return newly created instance of the FocusPointFeature class.
    */
-  FocusPointFeature createFocusPointFeature(@NonNull CameraProperties cameraProperties);
+  FocusPointFeature createFocusPointFeature(
+      @NonNull CameraProperties cameraProperties,
+      @NonNull SensorOrientationFeature sensorOrientationFeature);
 
   /**
    * Creates a new instance of the FPS range feature.
@@ -126,9 +130,13 @@ SensorOrientationFeature createSensorOrientationFeature(
    *
    * @param cameraProperties instance of the CameraProperties class containing information about the
    *     cameras features.
+   * @param sensorOrientationFeature instance of the SensorOrientationFeature class containing
+   *     information about the sensor and device orientation.
    * @return newly created instance of the ExposurePointFeature class.
    */
-  ExposurePointFeature createExposurePointFeature(@NonNull CameraProperties cameraProperties);
+  ExposurePointFeature createExposurePointFeature(
+      @NonNull CameraProperties cameraProperties,
+      @NonNull SensorOrientationFeature sensorOrientationFeature);
 
   /**
    * Creates a new instance of the noise reduction feature.

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

@@ -59,8 +59,10 @@ public ResolutionFeature createResolutionFeature(
   }
 
   @Override
-  public FocusPointFeature createFocusPointFeature(@NonNull CameraProperties cameraProperties) {
-    return new FocusPointFeature(cameraProperties);
+  public FocusPointFeature createFocusPointFeature(
+      @NonNull CameraProperties cameraProperties,
+      @NonNull SensorOrientationFeature sensorOrientationFeature) {
+    return new FocusPointFeature(cameraProperties, sensorOrientationFeature);
   }
 
   @Override
@@ -83,8 +85,9 @@ public ZoomLevelFeature createZoomLevelFeature(@NonNull CameraProperties cameraP
 
   @Override
   public ExposurePointFeature createExposurePointFeature(
-      @NonNull CameraProperties cameraProperties) {
-    return new ExposurePointFeature(cameraProperties);
+      @NonNull CameraProperties cameraProperties,
+      @NonNull SensorOrientationFeature sensorOrientationFeature) {
+    return new ExposurePointFeature(cameraProperties, sensorOrientationFeature);
   }
 
   @Override

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

@@ -8,25 +8,30 @@
 import android.hardware.camera2.params.MeteringRectangle;
 import android.util.Size;
 import androidx.annotation.NonNull;
+import io.flutter.embedding.engine.systemchannels.PlatformChannel;
 import io.flutter.plugins.camera.CameraProperties;
 import io.flutter.plugins.camera.CameraRegionUtils;
 import io.flutter.plugins.camera.features.CameraFeature;
 import io.flutter.plugins.camera.features.Point;
+import io.flutter.plugins.camera.features.sensororientation.SensorOrientationFeature;
 
 /** Exposure point controls where in the frame exposure metering will come from. */
 public class ExposurePointFeature extends CameraFeature<Point> {
 
   private Size cameraBoundaries;
   private Point exposurePoint;
   private MeteringRectangle exposureRectangle;
+  private final SensorOrientationFeature sensorOrientationFeature;
 
   /**
    * Creates a new instance of the {@link ExposurePointFeature}.
    *
    * @param cameraProperties Collection of the characteristics for the current camera device.
    */
-  public ExposurePointFeature(CameraProperties cameraProperties) {
+  public ExposurePointFeature(
+      CameraProperties cameraProperties, SensorOrientationFeature sensorOrientationFeature) {
     super(cameraProperties);
+    this.sensorOrientationFeature = sensorOrientationFeature;
   }
 
   /**
@@ -80,9 +85,15 @@ private void buildExposureRectangle() {
     if (this.exposurePoint == null) {
       this.exposureRectangle = null;
     } else {
+      PlatformChannel.DeviceOrientation orientation =
+          this.sensorOrientationFeature.getLockedCaptureOrientation();
+      if (orientation == null) {
+        orientation =
+            this.sensorOrientationFeature.getDeviceOrientationManager().getLastUIOrientation();
+      }
       this.exposureRectangle =
           CameraRegionUtils.convertPointToMeteringRectangle(
-              this.cameraBoundaries, this.exposurePoint.x, this.exposurePoint.y);
+              this.cameraBoundaries, this.exposurePoint.x, this.exposurePoint.y, orientation);
     }
   }
 }

packages/camera/camera/android/src/main/java/io/flutter/plugins/camera/features/focuspoint/FocusPointFeature.java

@@ -8,25 +8,30 @@
 import android.hardware.camera2.params.MeteringRectangle;
 import android.util.Size;
 import androidx.annotation.NonNull;
+import io.flutter.embedding.engine.systemchannels.PlatformChannel;
 import io.flutter.plugins.camera.CameraProperties;
 import io.flutter.plugins.camera.CameraRegionUtils;
 import io.flutter.plugins.camera.features.CameraFeature;
 import io.flutter.plugins.camera.features.Point;
+import io.flutter.plugins.camera.features.sensororientation.SensorOrientationFeature;
 
 /** Focus point controls where in the frame focus will come from. */
 public class FocusPointFeature extends CameraFeature<Point> {
 
   private Size cameraBoundaries;
   private Point focusPoint;
   private MeteringRectangle focusRectangle;
+  private final SensorOrientationFeature sensorOrientationFeature;
 
   /**
    * Creates a new instance of the {@link FocusPointFeature}.
    *
    * @param cameraProperties Collection of the characteristics for the current camera device.
    */
-  public FocusPointFeature(CameraProperties cameraProperties) {
+  public FocusPointFeature(
+      CameraProperties cameraProperties, SensorOrientationFeature sensorOrientationFeature) {
     super(cameraProperties);
+    this.sensorOrientationFeature = sensorOrientationFeature;
   }
 
   /**
@@ -80,9 +85,15 @@ private void buildFocusRectangle() {
     if (this.focusPoint == null) {
       this.focusRectangle = null;
     } else {
+      PlatformChannel.DeviceOrientation orientation =
+          this.sensorOrientationFeature.getLockedCaptureOrientation();
+      if (orientation == null) {
+        orientation =
+            this.sensorOrientationFeature.getDeviceOrientationManager().getLastUIOrientation();
+      }
       this.focusRectangle =
           CameraRegionUtils.convertPointToMeteringRectangle(
-              this.cameraBoundaries, this.focusPoint.x, this.focusPoint.y);
+              this.cameraBoundaries, this.focusPoint.x, this.focusPoint.y, orientation);
     }
   }
 }