Modify java side

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

@@ -97,6 +97,10 @@ public void setUp(
         binaryMessenger, pendingRecordingHostApiImpl);
     videoCaptureHostApiImpl = new VideoCaptureHostApiImpl(binaryMessenger, instanceManager);
     GeneratedCameraXLibrary.VideoCaptureHostApi.setup(binaryMessenger, videoCaptureHostApiImpl);
+    GeneratedCameraXLibrary.FallbackStrategyApi.setup(
+        binaryMessenger, new FallbackStrategyApiImpl(instanceManager));
+    GeneratedCameraXLibrary.QualitySelectorHostApi.setup(
+        binaryMessenger, new QualitySelectorHostApiImpl(instanceManager));
   }
 
   @Override

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

@@ -33,31 +33,7 @@ public FallbackStrategy create(
         @NonNull QualityConstraint qualityConstraint,
         @NonNull VideoResolutionFallbackRule fallbackRule) {
       // Determined proper CameraX Quality.
-      Quality quality = null;
-      switch (qualityConstraint) {
-        case SD:
-          quality = Quality.SD;
-          break;
-        case HD:
-          quality = Quality.HD;
-          break;
-        case FHD:
-          quality = Quality.FHD;
-          break;
-        case UHD:
-          quality = Quality.UHD;
-          break;
-        case LOWEST:
-          quality = Quality.LOWEST;
-          break;
-        case HIGHEST:
-          quality = Quality.HIGHEST;
-          break;
-      }
-
-      if (quality == null) {
-        throw new IllegalArgumentException("whoops");
-      }
+      Quality quality = QualitySelectorHostApiImpl.getCameraXQualityFromQuality(qualityConstraint);
 
       // Construct proper FallbackStrategy.
       switch (fallbackRule) {
@@ -81,7 +57,6 @@ public FallbackStrategy create(
    * @param instanceManager maintains instances stored to communicate with attached Dart objects
    */
   public FallbackStrategyHostApiImpl(@NonNull InstanceManager instanceManager) {
-
     this(instanceManager, new FallbackStrategyProxy());
   }
 

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

@@ -33,27 +33,24 @@ public class QualitySelectorHostApiImpl implements QualitySelectorHostApi {
   /** Proxy for constructors and static method of {@link QualitySelector}. */
   @VisibleForTesting
   public static class QualitySelectorProxy {
-
     /** Creates an instance of {@link QualitySelector}. */
     public QualitySelector create(
         @NonNull List<Long> qualityIndexList, @Nullable FallbackStrategy fallbackStrategy) {
       List<Quality> qualityList = new ArrayList<Quality>();
       for (Long qualityIndex : qualityIndexList) {
         qualityList.add(getQualityConstant(qualityIndex));
       }
-
-      if (qualityList.size() == 1) {
+
+      boolean fallbackStrategySpecified = fallbackStrategy != null;
+      if (qualityList.size() == 0) {
+        throw new IllegalArgumentException("List of at least one Quality must be supplied to create QualitySelector.");
+      }
+      else if (qualityList.size() == 1) {
         Quality quality = qualityList.get(0);
-        if (fallbackStrategy == null) {
-          return QualitySelector.from(quality);
-        }
-        return QualitySelector.from(quality, fallbackStrategy);
+        return fallbackStrategySpecified ? QualitySelector.from(quality, fallbackStrategy) : QualitySelector.from(quality);
       }
 
-      if (fallbackStrategy == null) {
-        return QualitySelector.fromOrderedList(qualityList);
-      }
-      return QualitySelector.fromOrderedList(qualityList);
+      return fallbackStrategySpecified ? QualitySelector.fromOrderedList(qualityList, fallbackStrategy) : QualitySelector.fromOrderedList(qualityList);
     }
 
     private Quality getQualityConstant(@NonNull Long qualityIndex) {
@@ -68,7 +65,6 @@ private Quality getQualityConstant(@NonNull Long qualityIndex) {
    * @param instanceManager maintains instances stored to communicate with attached Dart objects
    */
   public QualitySelectorHostApiImpl(@NonNull InstanceManager instanceManager) {
-
     this(instanceManager, new QualitySelectorProxy());
   }
 
@@ -133,6 +129,6 @@ public static Quality getCameraXQualityFromQuality(QualityConstraint quality) {
       case HIGHEST:
         return Quality.HIGHEST;
     }
-    throw new IllegalArgumentException("whoops");
+    throw new IllegalArgumentException("QualityConstraint " + quality + " is unhandled by QualitySelectorHostApiImpl.");
   }
 }

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

@@ -12,6 +12,7 @@
 import androidx.annotation.VisibleForTesting;
 import androidx.camera.video.FileOutputOptions;
 import androidx.camera.video.PendingRecording;
+import androidx.camera.video.QualitySelector;
 import androidx.camera.video.Recorder;
 import androidx.core.content.ContextCompat;
 import io.flutter.plugin.common.BinaryMessenger;

packages/camera/camera_android_camerax/android/src/test/java/io/flutter/plugins/camerax/FallbackStrategyTest.java

@@ -3,17 +3,17 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// TODO(bparrishMines): Remove GenApiImpls from filename or copy classes/methods to your own implementation
-
 package io.flutter.plugins.camerax;
 
-// TODO(bparrishMines): Import native classes
 import static org.junit.Assert.assertEquals;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import androidx.camera.video.FallbackStrategy;
+import androidx.camera.video.Quality;
 import io.flutter.plugin.common.BinaryMessenger;
 import io.flutter.plugins.camerax.GeneratedCameraXLibrary.FallbackStrategyFlutterApi;
 import java.util.Objects;
@@ -28,13 +28,9 @@
 public class FallbackStrategyTest {
 
   @Rule public MockitoRule mockitoRule = MockitoJUnit.rule();
-
   @Mock public FallbackStrategy mockFallbackStrategy;
-
   @Mock public BinaryMessenger mockBinaryMessenger;
-
   @Mock public FallbackStrategyFlutterApi mockFlutterApi;
-
   @Mock public FallbackStrategyHostApiImpl.FallbackStrategyProxy mockProxy;
 
   InstanceManager instanceManager;
@@ -50,38 +46,87 @@ public void tearDown() {
   }
 
   @Test
-  public void hostApiCreate() {
-
-    final Quality quality = Quality.SOME_ENUM_VALUE;
-
-    final VideoResolutionFallbackRule fallbackRule = VideoResolutionFallbackRule.SOME_ENUM_VALUE;
-
-    when(mockProxy.create(quality, fallbackRule)).thenReturn(mockFallbackStrategy);
-
+  public void hostApiCreate_makesCallToCreateExpectedFallbackStrategy() {
     final FallbackStrategyHostApiImpl hostApi =
-        new FallbackStrategyHostApiImpl(mockBinaryMessenger, instanceManager, mockProxy);
-
-    final long instanceIdentifier = 0;
-    hostApi.create(instanceIdentifier, quality, fallbackRule);
-
-    assertEquals(instanceManager.getInstance(instanceIdentifier), mockFallbackStrategy);
-  }
-
-  @Test
-  public void flutterApiCreate() {
-    final FallbackStrategyFlutterApiImpl flutterApi =
-        new FallbackStrategyFlutterApiImpl(mockBinaryMessenger, instanceManager);
-    flutterApi.setApi(mockFlutterApi);
-
-    final Quality quality = Quality.SOME_ENUM_VALUE;
-
-    final VideoResolutionFallbackRule fallbackRule = VideoResolutionFallbackRule.SOME_ENUM_VALUE;
-
-    flutterApi.create(mockFallbackStrategy, quality, fallbackRule, reply -> {});
-
-    final long instanceIdentifier =
-        Objects.requireNonNull(
-            instanceManager.getIdentifierForStrongReference(mockFallbackStrategy));
-    verify(mockFlutterApi).create(eq(instanceIdentifier), eq(quality), eq(fallbackRule), any());
+    new FallbackStrategyHostApiImpl(mockBinaryMessenger, instanceManager, mockProxy);
+    final long instanceIdentifier = 45;
+    final FallbackStrategy mockFallbackStrategy = mock(FallbackStrategy.class);
+
+    try (MockedStatic<FallbackStrategy> mockedFallbackStrategy =
+      mockStatic(FallbackStrategy.class)) {
+      for (QualityConstraint quality : QualityConstraint.values()) {
+        for (VideoResolutionFallbackRule fallbackRule : VideoResolutionFallbackRule.values()) {
+          // Determine expected Quality based on QualityConstraint.
+          Quality expectedQuality;
+          switch (quality) {
+            case SD:
+              expectedQuality = Quality.SD;
+              break;
+            case HD:
+              expectedQuality =  Quality.HD;
+              break;
+            case FHD:
+              expectedQuality =  Quality.FHD;
+              break;
+            case UHD:
+              expectedQuality =  Quality.UHD;
+              break;
+            case LOWEST:
+              expectedQuality =  Quality.LOWEST;
+              break;
+            case HIGHEST:
+              expectedQuality =  Quality.HIGHEST;
+              break;
+            default:
+              fail(
+              "The QualityConstraint "
+                  + quality.toString()
+                  + "is unhandled by this test.");
+          }
+          // Mock calls to create FallbackStrategy according to fallbackRule being tested.
+          switch(fallbackRule) {
+            case HIGHER_QUALITY_OR_LOWER_THAN:
+              mockedFallbackStrategy
+                .when(() -> FallbackStrategy.higherQualityOrLowerThan(expectedQuality))
+                .thenAnswer(
+                    (Answer<FallbackStrategy>)
+                        invocation -> mockFallbackStrategy);
+              break;
+            case HIGHER_QUALITY_THAN:
+              mockedFallbackStrategy
+                .when(() -> FallbackStrategy.higherQualityThan(expectedQuality))
+                .thenAnswer(
+                    (Answer<FallbackStrategy>)
+                        invocation -> mockFallbackStrategy);
+              break;
+            case LOWER_QUALITY_OR_HIGHER_THAN:
+              mockedFallbackStrategy
+                .when(() -> FallbackStrategy.lowerQualityOrHigherThan(expectedQuality))
+                .thenAnswer(
+                    (Answer<FallbackStrategy>)
+                        invocation -> mockFallbackStrategy);
+              break;
+            case LOWER_QUALITY_THAN:
+              mockedFallbackStrategy
+                .when(() -> FallbackStrategy.lowerQualityThan(expectedQuality))
+                .thenAnswer(
+                    (Answer<FallbackStrategy>)
+                        invocation -> mockFallbackStrategy);
+              break;
+            default:
+              fail(
+              "The VideoResolutionFallbackRule "
+                  + fallbackRule.toString()
+                  + "is unhandled by this test.");
+          }
+          hostApi.create(instanceIdentifier, quality, fallbackRule);
+          assertEquals(instanceManager.getInstance(instanceIdentifier), mockFallbackStrategy);
+
+          // Clear FallbackStrategy mock and InstanceManager.
+          mockedFallbackStrategy.clear();
+          instanceManager.clear();
+        }
+      }
+    }
   }
 }

packages/camera/camera_android_camerax/android/src/test/java/io/flutter/plugins/camerax/RecorderTest.java

@@ -18,6 +18,7 @@
 import android.content.Context;
 import androidx.camera.video.FileOutputOptions;
 import androidx.camera.video.PendingRecording;
+import androidx.camera.video.QualitySelector;
 import androidx.camera.video.Recorder;
 import androidx.test.core.app.ApplicationProvider;
 import io.flutter.plugin.common.BinaryMessenger;
@@ -56,26 +57,29 @@ public void tearDown() {
   }
 
   @Test
-  public void createTest() {
+  public void create_createsExpectedRecorderInstance() {
     final int recorderId = 0;
     final int aspectRatio = 1;
     final int bitRate = 2;
+    final int qualitySelectorId = 3;
 
     final RecorderHostApiImpl recorderHostApi =
         new RecorderHostApiImpl(mockBinaryMessenger, testInstanceManager, context);
 
     final CameraXProxy mockCameraXProxy = mock(CameraXProxy.class);
     final Recorder.Builder mockRecorderBuilder = mock(Recorder.Builder.class);
+    final QualitySelector mockQualitySelector = mock(QualitySelector.class);
     recorderHostApi.cameraXProxy = mockCameraXProxy;
     when(mockCameraXProxy.createRecorderBuilder()).thenReturn(mockRecorderBuilder);
     when(mockRecorderBuilder.setAspectRatio(aspectRatio)).thenReturn(mockRecorderBuilder);
     when(mockRecorderBuilder.setTargetVideoEncodingBitRate(bitRate))
         .thenReturn(mockRecorderBuilder);
     when(mockRecorderBuilder.setExecutor(any(Executor.class))).thenReturn(mockRecorderBuilder);
     when(mockRecorderBuilder.build()).thenReturn(mockRecorder);
+    testInstanceManager.addDartCreatedInstance(mockQualitySelector, Long.valueOf(qualitySelectorId));
 
     recorderHostApi.create(
-        Long.valueOf(recorderId), Long.valueOf(aspectRatio), Long.valueOf(bitRate));
+        Long.valueOf(recorderId), Long.valueOf(aspectRatio), Long.valueOf(bitRate), Long.valueOf(qualitySelectorId));
     verify(mockCameraXProxy).createRecorderBuilder();
     verify(mockRecorderBuilder).setAspectRatio(aspectRatio);
     verify(mockRecorderBuilder).setTargetVideoEncodingBitRate(bitRate);