[camerax] Implement resolution configuration

packages/camera/camera_android_camerax/CHANGELOG.md

@@ -1,6 +1,7 @@
-## NEXT
+## 0.5.0+16
 
 * Updates minimum supported SDK version to Flutter 3.7/Dart 2.19.
+* Implements resolution configuration for all camera use cases.
 
 ## 0.5.0+15
 

packages/camera/camera_android_camerax/README.md

@@ -24,16 +24,18 @@ dependencies:
 
 ## Missing features and limitations
 
-### Resolution configuration \[[Issue #120462][120462]\]
 
-Any specified `ResolutionPreset` wll go unused in favor of CameraX defaults and
-`onCameraResolutionChanged` is unimplemented.
+### 240p resolution configuration for video recording
+
+240p resolution configuration for video recording is unsupported by CameraX,
+and thus, the plugin will fall back to 480p if configured with a
+`ResolutionPreset`.
 
 ### Locking/Unlocking capture orientation \[[Issue #125915][125915]\]
 
 `lockCaptureOrientation` & `unLockCaptureOrientation` are unimplemented.
 
-### Flash mode configuration \[[Issue #120715][120715]\]
+### Torch mode \[[Issue #120715][120715]\]
 
 Calling `setFlashMode` with mode `FlashMode.torch` currently does nothing.
 

packages/camera/camera_android_camerax/android/src/main/java/io/flutter/plugins/camerax/GeneratedCameraXLibrary.java

@@ -127,7 +127,11 @@ private VideoQualityConstraint(final int index) {
     }
   }
 
-  /** Fallback rules for selecting video resolution. */
+  /**
+   * Fallback rules for selecting video resolution.
+   *
+   * <p>See https://developer.android.com/reference/androidx/camera/video/FallbackStrategy.
+   */
   public enum VideoResolutionFallbackRule {
     HIGHER_QUALITY_OR_LOWER_THAN(0),
     HIGHER_QUALITY_THAN(1),

packages/camera/camera_android_camerax/android/src/main/java/io/flutter/plugins/camerax/QualitySelectorHostApiImpl.java

@@ -38,7 +38,8 @@ public static class QualitySelectorProxy {
         @Nullable FallbackStrategy fallbackStrategy) {
       // Convert each index of VideoQualityConstraint to Quality.
       List<Quality> qualityList = new ArrayList<Quality>();
-      for (Long qualityIndex : videoQualityConstraintIndexList) {
+      for (int i = 0; i < videoQualityConstraintIndexList.size(); i++) {
+        int qualityIndex = ((Number) videoQualityConstraintIndexList.get(i)).intValue();
         qualityList.add(getQualityConstant(qualityIndex));
       }
 
@@ -59,8 +60,8 @@ public static class QualitySelectorProxy {
     }
 
     /** Converts from index of {@link VideoQualityConstraint} to {@link Quality}. */
-    private Quality getQualityConstant(@NonNull Long qualityIndex) {
-      VideoQualityConstraint quality = VideoQualityConstraint.values()[qualityIndex.intValue()];
+    private Quality getQualityConstant(@NonNull int qualityIndex) {
+      VideoQualityConstraint quality = VideoQualityConstraint.values()[qualityIndex];
       return getQualityFromVideoQualityConstraint(quality);
     }
   }

packages/camera/camera_android_camerax/example/integration_test/integration_test.dart

@@ -2,11 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import 'dart:async';
 import 'dart:io';
 import 'dart:ui';
 
 import 'package:camera_android_camerax/camera_android_camerax.dart';
 import 'package:camera_android_camerax_example/camera_controller.dart';
+import 'package:camera_android_camerax_example/camera_image.dart';
 import 'package:camera_platform_interface/camera_platform_interface.dart';
 import 'package:flutter/painting.dart';
 import 'package:flutter_test/flutter_test.dart';
@@ -19,6 +21,46 @@ void main() {
     CameraPlatform.instance = AndroidCameraCameraX();
   });
 
+  final Map<ResolutionPreset, Size> presetExpectedSizes =
+      <ResolutionPreset, Size>{
+    ResolutionPreset.low: const Size(240, 320),
+    ResolutionPreset.medium: const Size(480, 720),
+    ResolutionPreset.high: const Size(720, 1280),
+    ResolutionPreset.veryHigh: const Size(1080, 1920),
+    ResolutionPreset.ultraHigh: const Size(2160, 3840),
+    // Don't bother checking for max here since it could be anything.
+  };
+
+  /// Verify that [actual] has dimensions that are at least as large as
+  /// [expectedSize]. Allows for a mismatch in portrait vs landscape. Returns
+  /// whether the dimensions exactly match.
+  bool assertExpectedDimensions(Size expectedSize, Size actual) {
+    expect(actual.shortestSide, lessThanOrEqualTo(expectedSize.shortestSide));
+    expect(actual.longestSide, lessThanOrEqualTo(expectedSize.longestSide));
+    return actual.shortestSide == expectedSize.shortestSide &&
+        actual.longestSide == expectedSize.longestSide;
+  }
+
+  // This tests that the capture is no bigger than the preset, since we have
+  // automatic code to fall back to smaller sizes when we need to. Returns
+  // whether the image is exactly the desired resolution.
+  Future<bool> testCaptureImageResolution(
+      CameraController controller, ResolutionPreset preset) async {
+    final Size expectedSize = presetExpectedSizes[preset]!;
+
+    // Take Picture
+    final XFile file = await controller.takePicture();
+
+    // Load picture
+    final File fileImage = File(file.path);
+    final Image image = await decodeImageFromList(fileImage.readAsBytesSync());
+
+    // Verify image dimensions are as expected
+    expect(image, isNotNull);
+    return assertExpectedDimensions(
+        expectedSize, Size(image.height.toDouble(), image.width.toDouble()));
+  }
+
   testWidgets('availableCameras only supports valid back or front cameras',
       (WidgetTester tester) async {
     final List<CameraDescription> availableCameras =
@@ -31,27 +73,94 @@ void main() {
     }
   });
 
-  testWidgets('takePictures stores a valid image in memory',
+  testWidgets('Capture specific image resolutions',
       (WidgetTester tester) async {
-    final List<CameraDescription> availableCameras =
+    final List<CameraDescription> cameras =
         await CameraPlatform.instance.availableCameras();
-    if (availableCameras.isEmpty) {
+    if (cameras.isEmpty) {
       return;
     }
-    for (final CameraDescription cameraDescription in availableCameras) {
-      final CameraController controller =
-          CameraController(cameraDescription, ResolutionPreset.high);
-      await controller.initialize();
+    for (final CameraDescription cameraDescription in cameras) {
+      bool previousPresetExactlySupported = true;
+      for (final MapEntry<ResolutionPreset, Size> preset
+          in presetExpectedSizes.entries) {
+        final CameraController controller =
+            CameraController(cameraDescription, preset.key);
+        await controller.initialize();
+        final bool presetExactlySupported =
+            await testCaptureImageResolution(controller, preset.key);
+        expect(!(!previousPresetExactlySupported && presetExactlySupported),
+            isTrue,
+            reason:
+                'The camera took higher resolution pictures at a lower resolution.');
+        previousPresetExactlySupported = presetExactlySupported;
+        await controller.dispose();
+      }
+    }
+  });
+
+  testWidgets('Preview takes expected resolution from preset',
+      (WidgetTester tester) async {
+    final List<CameraDescription> cameras =
+        await CameraPlatform.instance.availableCameras();
+    if (cameras.isEmpty) {
+      return;
+    }
+    for (final CameraDescription cameraDescription in cameras) {
+      bool previousPresetExactlySupported = true;
+      for (final MapEntry<ResolutionPreset, Size> preset
+          in presetExpectedSizes.entries) {
+        final CameraController controller =
+            CameraController(cameraDescription, preset.key);
+
+        await controller.initialize();
+
+        while (controller.value.previewSize == null) {
+          // Wait for preview size to update.
+        }
+
+        final bool presetExactlySupported = assertExpectedDimensions(
+            presetExpectedSizes[preset.key]!, controller.value.previewSize!);
+        expect(!(!previousPresetExactlySupported && presetExactlySupported),
+            isTrue,
+            reason: 'The preview has a lower resolution than that specified.');
+        previousPresetExactlySupported = presetExactlySupported;
+        await controller.dispose();
+      }
+    }
+  });
 
-      // Take Picture
-      final XFile file = await controller.takePicture();
+  testWidgets('Images from streaming have expected resolution from preset',
+      (WidgetTester tester) async {
+    final List<CameraDescription> cameras =
+        await CameraPlatform.instance.availableCameras();
+    if (cameras.isEmpty) {
+      return;
+    }
+    for (final CameraDescription cameraDescription in cameras) {
+      bool previousPresetExactlySupported = true;
+      for (final MapEntry<ResolutionPreset, Size> preset
+          in presetExpectedSizes.entries) {
+        final CameraController controller =
+            CameraController(cameraDescription, preset.key);
+        final Completer<CameraImage> imageCompleter = Completer<CameraImage>();
+        await controller.initialize();
+        await controller.startImageStream((CameraImage image) {
+          imageCompleter.complete(image);
+          controller.stopImageStream();
+        });
 
-      // Try loading picture
-      final File fileImage = File(file.path);
-      final Image image =
-          await decodeImageFromList(fileImage.readAsBytesSync());
+        final CameraImage image = await imageCompleter.future;
+        final bool presetExactlySupported = assertExpectedDimensions(
+            presetExpectedSizes[preset.key]!,
+            Size(image.height.toDouble(), image.width.toDouble()));
+        expect(!(!previousPresetExactlySupported && presetExactlySupported),
+            isTrue,
+            reason: 'The preview has a lower resolution than that specified.');
+        previousPresetExactlySupported = presetExactlySupported;
 
-      expect(image, isNotNull);
+        await controller.dispose();
+      }
     }
   });
 }