Add new files

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

@@ -0,0 +1,114 @@
+
+// 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.camerax;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
+import androidx.camera.video.FallbackStrategy;
+import androidx.camera.video.Quality;
+import io.flutter.plugins.camerax.GeneratedCameraXLibrary.FallbackStrategyHostApi;
+import io.flutter.plugins.camerax.GeneratedCameraXLibrary.QualityConstraint;
+import io.flutter.plugins.camerax.GeneratedCameraXLibrary.VideoResolutionFallbackRule;
+import java.util.Objects;
+
+/**
+ * Host API implementation for {@link FallbackStrategy}.
+ *
+ * <p>This class may handle instantiating and adding native object instances that are attached to a
+ * Dart instance or handle method calls on the associated native class or an instance of the class.
+ */
+public class FallbackStrategyHostApiImpl implements FallbackStrategyHostApi {
+  private final InstanceManager instanceManager;
+
+  private final FallbackStrategyProxy proxy;
+
+  /** Proxy for constructors and static method of {@link FallbackStrategy}. */
+  @VisibleForTesting
+  public static class FallbackStrategyProxy {
+    /** Creates an instance of {@link FallbackStrategy}. */
+    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");
+      }
+
+      // Construct proper FallbackStrategy.
+      switch (fallbackRule) {
+        case HIGHER_QUALITY_OR_LOWER_THAN:
+          return FallbackStrategy.higherQualityOrLowerThan(quality);
+        case HIGHER_QUALITY_THAN:
+          return FallbackStrategy.higherQualityThan(quality);
+        case LOWER_QUALITY_OR_HIGHER_THAN:
+          return FallbackStrategy.lowerQualityOrHigherThan(quality);
+        case LOWER_QUALITY_THAN:
+          return FallbackStrategy.lowerQualityThan(quality);
+      }
+
+      throw new IllegalArgumentException("whoops");
+    }
+  }
+
+  /**
+   * Constructs a {@link FallbackStrategyHostApiImpl}.
+   *
+   * @param instanceManager maintains instances stored to communicate with attached Dart objects
+   */
+  public FallbackStrategyHostApiImpl(@NonNull InstanceManager instanceManager) {
+
+    this(instanceManager, new FallbackStrategyProxy());
+  }
+
+  /**
+   * Constructs a {@link FallbackStrategyHostApiImpl}.
+   *
+   * @param instanceManager maintains instances stored to communicate with attached Dart objects
+   * @param proxy proxy for constructors and static method of {@link FallbackStrategy}
+   */
+  @VisibleForTesting
+  FallbackStrategyHostApiImpl(
+      @NonNull InstanceManager instanceManager, @NonNull FallbackStrategyProxy proxy) {
+    this.instanceManager = instanceManager;
+    this.proxy = proxy;
+  }
+
+  @Override
+  public void create(
+      @NonNull Long identifier,
+      @NonNull QualityConstraint qualityConstraint,
+      @NonNull VideoResolutionFallbackRule fallbackRule) {
+
+    instanceManager.addDartCreatedInstance(
+        proxy.create(qualityConstraint, fallbackRule), identifier);
+  }
+
+  private FallbackStrategy getFallbackStrategyInstance(@NonNull Long identifier) {
+    return Objects.requireNonNull(instanceManager.getInstance(identifier));
+  }
+}

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

@@ -0,0 +1,138 @@
+
+// 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.camerax;
+
+import android.util.Size;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import androidx.camera.video.FallbackStrategy;
+import androidx.camera.video.Quality;
+import androidx.camera.video.QualitySelector;
+import io.flutter.plugins.camerax.GeneratedCameraXLibrary.QualityConstraint;
+import io.flutter.plugins.camerax.GeneratedCameraXLibrary.QualitySelectorHostApi;
+import io.flutter.plugins.camerax.GeneratedCameraXLibrary.ResolutionInfo;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Host API implementation for {@link QualitySelector}.
+ *
+ * <p>This class may handle instantiating and adding native object instances that are attached to a
+ * Dart instance or handle method calls on the associated native class or an instance of the class.
+ */
+public class QualitySelectorHostApiImpl implements QualitySelectorHostApi {
+  private final InstanceManager instanceManager;
+
+  private final QualitySelectorProxy proxy;
+
+  /** 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) {
+        Quality quality = qualityList.get(0);
+        if (fallbackStrategy == null) {
+          return QualitySelector.from(quality);
+        }
+        return QualitySelector.from(quality, fallbackStrategy);
+      }
+
+      if (fallbackStrategy == null) {
+        return QualitySelector.fromOrderedList(qualityList);
+      }
+      return QualitySelector.fromOrderedList(qualityList);
+    }
+
+    private Quality getQualityConstant(@NonNull Long qualityIndex) {
+      QualityConstraint quality = QualityConstraint.values()[qualityIndex.intValue()];
+      return getCameraXQualityFromQuality(quality);
+    }
+  }
+
+  /**
+   * Constructs a {@link QualitySelectorHostApiImpl}.
+   *
+   * @param instanceManager maintains instances stored to communicate with attached Dart objects
+   */
+  public QualitySelectorHostApiImpl(@NonNull InstanceManager instanceManager) {
+
+    this(instanceManager, new QualitySelectorProxy());
+  }
+
+  /**
+   * Constructs a {@link QualitySelectorHostApiImpl}.
+   *
+   * @param instanceManager maintains instances stored to communicate with attached Dart objects
+   * @param proxy proxy for constructors and static method of {@link QualitySelector}
+   */
+  @VisibleForTesting
+  QualitySelectorHostApiImpl(
+      @NonNull InstanceManager instanceManager, @NonNull QualitySelectorProxy proxy) {
+    this.instanceManager = instanceManager;
+    this.proxy = proxy;
+  }
+
+  @Override
+  public void create(
+      @NonNull Long identifier,
+      @NonNull List<Long> qualityList,
+      @Nullable Long fallbackStrategyIdentifier) {
+
+    instanceManager.addDartCreatedInstance(
+        proxy.create(
+            qualityList,
+            fallbackStrategyIdentifier == null
+                ? null
+                : Objects.requireNonNull(instanceManager.getInstance(fallbackStrategyIdentifier))),
+        identifier);
+  }
+
+  @Override
+  public ResolutionInfo getResolution(
+      @NonNull Long cameraInfoIdentifier, @NonNull QualityConstraint quality) {
+    final Size result =
+        QualitySelector.getResolution(
+            Objects.requireNonNull(instanceManager.getInstance(cameraInfoIdentifier)),
+            getCameraXQualityFromQuality(quality));
+
+    return new ResolutionInfo.Builder()
+        .setWidth(Long.valueOf(result.getWidth()))
+        .setHeight(Long.valueOf(result.getHeight()))
+        .build();
+  }
+
+  private QualitySelector getQualitySelectorInstance(@NonNull Long identifier) {
+    return Objects.requireNonNull(instanceManager.getInstance(identifier));
+  }
+
+  public static Quality getCameraXQualityFromQuality(QualityConstraint quality) {
+    switch (quality) {
+      case SD:
+        return Quality.SD;
+      case HD:
+        return Quality.HD;
+      case FHD:
+        return Quality.FHD;
+      case UHD:
+        return Quality.UHD;
+      case LOWEST:
+        return Quality.LOWEST;
+      case HIGHEST:
+        return Quality.HIGHEST;
+    }
+    throw new IllegalArgumentException("whoops");
+  }
+}

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

@@ -0,0 +1,87 @@
+
+// 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.
+
+// 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.verify;
+import static org.mockito.Mockito.when;
+
+import io.flutter.plugin.common.BinaryMessenger;
+import io.flutter.plugins.camerax.GeneratedCameraXLibrary.FallbackStrategyFlutterApi;
+import java.util.Objects;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+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;
+
+  @Before
+  public void setUp() {
+    instanceManager = InstanceManager.open(identifier -> {});
+  }
+
+  @After
+  public void tearDown() {
+    instanceManager.close();
+  }
+
+  @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);
+
+    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());
+  }
+}