[camera] Fix CamcorderProfile Usages

.ci/Dockerfile

@@ -5,10 +5,6 @@ FROM cirrusci/flutter:2.2.2
 
 RUN apt-get update -y
 
-# Required by Roboeletric and the Android SDK.
-RUN apt-get install -y openjdk-8-jdk
-ENV JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64
-
 RUN apt-get install -y --no-install-recommends gnupg
 
 # Add repo for gcloud sdk and install it

.cirrus.yml

@@ -220,11 +220,12 @@ task:
         -   echo "This user does not have permission to run Firebase Test Lab tests."
         - fi
       # Upload the full lint results to Cirrus to display in the results UI.
-      always:
-        android-lint_artifacts:
-          path: "**/reports/lint-results-debug.xml"
-          type: text/xml
-          format: android-lint
+      # TODO(camsim99): See https://github.com/flutter/flutter/issues/92201
+      # always:
+      #   android-lint_artifacts:
+      #     path: "**/reports/lint-results-debug.xml"
+      #     type: text/xml
+      #     format: android-lint
     ### Web tasks ###
     - name: web-platform_tests
       env:

packages/camera/camera/CHANGELOG.md

@@ -1,5 +1,8 @@
 ## 0.9.4+3
 
+* Change compileSdkVersion to 31.
+* Remove deprecated `CamcorderProfile`.
+* Update gradle version to 7.0.2.
 * Fix registerTexture and result being called on background thread on iOS.
 
 ## 0.9.4+2

packages/camera/camera/android/build.gradle

@@ -9,7 +9,7 @@ buildscript {
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.5.0'
+        classpath 'com.android.tools.build:gradle:7.0.2'
     }
 }
 
@@ -27,9 +27,10 @@ project.getTasks().withType(JavaCompile){
 apply plugin: 'com.android.library'
 
 android {
-    compileSdkVersion 29
+    compileSdkVersion 31
 
     defaultConfig {
+        targetSdkVersion 31
         minSdkVersion 21
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -60,7 +61,7 @@ android {
 dependencies {
     compileOnly 'androidx.annotation:annotation:1.1.0'
     testImplementation 'junit:junit:4.12'
-    testImplementation 'org.mockito:mockito-inline:3.12.4'
+    testImplementation 'org.mockito:mockito-inline:4.0.0'
     testImplementation 'androidx.test:core:1.3.0'
-    testImplementation 'org.robolectric:robolectric:4.3'
+    testImplementation 'org.robolectric:robolectric:4.5'
 }

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

@@ -20,6 +20,7 @@
 import android.hardware.camera2.params.OutputConfiguration;
 import android.hardware.camera2.params.SessionConfiguration;
 import android.media.CamcorderProfile;
+import android.media.EncoderProfiles;
 import android.media.Image;
 import android.media.ImageReader;
 import android.media.MediaRecorder;
@@ -199,8 +200,16 @@ private void prepareMediaRecorder(String outputFilePath) throws IOException {
         ((SensorOrientationFeature) cameraFeatures.getSensorOrientation())
             .getLockedCaptureOrientation();
 
+    MediaRecorderBuilder mediaRecorderBuilder;
+
+    if (Build.VERSION.SDK_INT >= 31) {
+      mediaRecorderBuilder = new MediaRecorderBuilder(getRecordingProfileOn31(), outputFilePath);
+    } else {
+      mediaRecorderBuilder = new MediaRecorderBuilder(getRecordingProfile(), outputFilePath);
+    }
+
     mediaRecorder =
-        new MediaRecorderBuilder(getRecordingProfile(), outputFilePath)
+        mediaRecorderBuilder
             .setEnableAudio(enableAudio)
             .setMediaOrientation(
                 lockedOrientation == null
@@ -923,6 +932,10 @@ CamcorderProfile getRecordingProfile() {
     return cameraFeatures.getResolution().getRecordingProfile();
   }
 
+  EncoderProfiles getRecordingProfileOn31() {
+    return cameraFeatures.getResolution().getRecordingProfileOn31();
+  }
+
   /** Shortut to get deviceOrientationListener. */
   DeviceOrientationManager getDeviceOrientationManager() {
     return cameraFeatures.getSensorOrientation().getDeviceOrientationManager();

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

@@ -4,12 +4,16 @@
 
 package io.flutter.plugins.camera.features.resolution;
 
+import android.annotation.TargetApi;
 import android.hardware.camera2.CaptureRequest;
 import android.media.CamcorderProfile;
+import android.media.EncoderProfiles;
+import android.os.Build;
 import android.util.Size;
 import androidx.annotation.VisibleForTesting;
 import io.flutter.plugins.camera.CameraProperties;
 import io.flutter.plugins.camera.features.CameraFeature;
+import java.util.List;
 
 /**
  * Controls the resolutions configuration on the {@link android.hardware.camera2} API.
@@ -22,6 +26,7 @@ public class ResolutionFeature extends CameraFeature<ResolutionPreset> {
   private Size captureSize;
   private Size previewSize;
   private CamcorderProfile recordingProfile;
+  private EncoderProfiles recordingProfileOn31;
   private ResolutionPreset currentSetting;
   private int cameraId;
 
@@ -55,6 +60,10 @@ public CamcorderProfile getRecordingProfile() {
     return this.recordingProfile;
   }
 
+  public EncoderProfiles getRecordingProfileOn31() {
+    return this.recordingProfileOn31;
+  }
+
   /**
    * Gets the optimal preview size based on the configured resolution.
    *
@@ -99,15 +108,25 @@ public void updateBuilder(CaptureRequest.Builder requestBuilder) {
     // No-op: when setting a resolution there is no need to update the request builder.
   }
 
+  @SuppressWarnings("deprecation")
   @VisibleForTesting
-  static Size computeBestPreviewSize(int cameraId, ResolutionPreset preset) {
+  static Size computeBestPreviewSize(int cameraId, ResolutionPreset preset)
+      throws IndexOutOfBoundsException {
     if (preset.ordinal() > ResolutionPreset.high.ordinal()) {
       preset = ResolutionPreset.high;
     }
-
-    CamcorderProfile profile =
-        getBestAvailableCamcorderProfileForResolutionPreset(cameraId, preset);
-    return new Size(profile.videoFrameWidth, profile.videoFrameHeight);
+    if (Build.VERSION.SDK_INT >= 31) {
+      EncoderProfiles profile =
+          getBestAvailableCamcorderProfileForResolutionPresetOn31(cameraId, preset);
+      List<EncoderProfiles.VideoProfile> videoProfiles = profile.getVideoProfiles();
+      EncoderProfiles.VideoProfile defaultVideoProfile = videoProfiles.get(0);
+
+      return new Size(defaultVideoProfile.getWidth(), defaultVideoProfile.getHeight());
+    } else {
+      CamcorderProfile profile =
+          getBestAvailableCamcorderProfileForResolutionPreset(cameraId, preset);
+      return new Size(profile.videoFrameWidth, profile.videoFrameHeight);
+    }
   }
 
   /**
@@ -121,6 +140,7 @@ static Size computeBestPreviewSize(int cameraId, ResolutionPreset preset) {
    * @return The best possible {@link android.media.CamcorderProfile} that matches the supplied
    *     {@link ResolutionPreset}.
    */
+  @SuppressWarnings("deprecation")
   public static CamcorderProfile getBestAvailableCamcorderProfileForResolutionPreset(
       int cameraId, ResolutionPreset preset) {
     if (cameraId < 0) {
@@ -164,13 +184,72 @@ public static CamcorderProfile getBestAvailableCamcorderProfileForResolutionPres
     }
   }
 
-  private void configureResolution(ResolutionPreset resolutionPreset, int cameraId) {
+  @TargetApi(Build.VERSION_CODES.S)
+  public static EncoderProfiles getBestAvailableCamcorderProfileForResolutionPresetOn31(
+      int cameraId, ResolutionPreset preset) {
+    if (cameraId < 0) {
+      throw new AssertionError(
+          "getBestAvailableCamcorderProfileForResolutionPreset can only be used with valid (>=0) camera identifiers.");
+    }
+
+    String cameraIdString = Integer.toString(cameraId);
+
+    switch (preset) {
+        // All of these cases deliberately fall through to get the best available profile.
+      case max:
+        if (CamcorderProfile.hasProfile(cameraId, CamcorderProfile.QUALITY_HIGH)) {
+          return CamcorderProfile.getAll(cameraIdString, CamcorderProfile.QUALITY_HIGH);
+        }
+      case ultraHigh:
+        if (CamcorderProfile.hasProfile(cameraId, CamcorderProfile.QUALITY_2160P)) {
+          return CamcorderProfile.getAll(cameraIdString, CamcorderProfile.QUALITY_2160P);
+        }
+      case veryHigh:
+        if (CamcorderProfile.hasProfile(cameraId, CamcorderProfile.QUALITY_1080P)) {
+          return CamcorderProfile.getAll(cameraIdString, CamcorderProfile.QUALITY_1080P);
+        }
+      case high:
+        if (CamcorderProfile.hasProfile(cameraId, CamcorderProfile.QUALITY_720P)) {
+          return CamcorderProfile.getAll(cameraIdString, CamcorderProfile.QUALITY_720P);
+        }
+      case medium:
+        if (CamcorderProfile.hasProfile(cameraId, CamcorderProfile.QUALITY_480P)) {
+          return CamcorderProfile.getAll(cameraIdString, CamcorderProfile.QUALITY_480P);
+        }
+      case low:
+        if (CamcorderProfile.hasProfile(cameraId, CamcorderProfile.QUALITY_QVGA)) {
+          return CamcorderProfile.getAll(cameraIdString, CamcorderProfile.QUALITY_QVGA);
+        }
+      default:
+        if (CamcorderProfile.hasProfile(cameraId, CamcorderProfile.QUALITY_LOW)) {
+          return CamcorderProfile.getAll(cameraIdString, CamcorderProfile.QUALITY_LOW);
+        }
+
+        throw new IllegalArgumentException(
+            "No capture session available for current capture session.");
+    }
+  }
+
+  @SuppressWarnings("deprecation")
+  private void configureResolution(ResolutionPreset resolutionPreset, int cameraId)
+      throws IndexOutOfBoundsException {
     if (!checkIsSupported()) {
       return;
     }
-    recordingProfile =
-        getBestAvailableCamcorderProfileForResolutionPreset(cameraId, resolutionPreset);
-    captureSize = new Size(recordingProfile.videoFrameWidth, recordingProfile.videoFrameHeight);
+
+    if (Build.VERSION.SDK_INT >= 31) {
+      recordingProfileOn31 =
+          getBestAvailableCamcorderProfileForResolutionPresetOn31(cameraId, resolutionPreset);
+      List<EncoderProfiles.VideoProfile> videoProfiles = recordingProfileOn31.getVideoProfiles();
+
+      EncoderProfiles.VideoProfile defaultVideoProfile = videoProfiles.get(0);
+      captureSize = new Size(defaultVideoProfile.getWidth(), defaultVideoProfile.getHeight());
+    } else {
+      recordingProfile =
+          getBestAvailableCamcorderProfileForResolutionPreset(cameraId, resolutionPreset);
+      captureSize = new Size(recordingProfile.videoFrameWidth, recordingProfile.videoFrameHeight);
+    }
+
     previewSize = computeBestPreviewSize(cameraId, resolutionPreset);
   }
 }

packages/camera/camera/android/src/main/java/io/flutter/plugins/camera/media/MediaRecorderBuilder.java

@@ -5,35 +5,55 @@
 package io.flutter.plugins.camera.media;
 
 import android.media.CamcorderProfile;
+import android.media.EncoderProfiles;
 import android.media.MediaRecorder;
+import android.os.Build;
 import androidx.annotation.NonNull;
 import java.io.IOException;
 
 public class MediaRecorderBuilder {
+  @SuppressWarnings("deprecation")
   static class MediaRecorderFactory {
     MediaRecorder makeMediaRecorder() {
       return new MediaRecorder();
     }
   }
 
   private final String outputFilePath;
-  private final CamcorderProfile recordingProfile;
+  private final CamcorderProfile camcorderProfile;
+  private final EncoderProfiles encoderProfiles;
   private final MediaRecorderFactory recorderFactory;
 
   private boolean enableAudio;
   private int mediaOrientation;
 
   public MediaRecorderBuilder(
-      @NonNull CamcorderProfile recordingProfile, @NonNull String outputFilePath) {
-    this(recordingProfile, outputFilePath, new MediaRecorderFactory());
+      @NonNull CamcorderProfile camcorderProfile, @NonNull String outputFilePath) {
+    this(camcorderProfile, outputFilePath, new MediaRecorderFactory());
+  }
+
+  public MediaRecorderBuilder(
+      @NonNull EncoderProfiles encoderProfiles, @NonNull String outputFilePath) {
+    this(encoderProfiles, outputFilePath, new MediaRecorderFactory());
   }
 
   MediaRecorderBuilder(
-      @NonNull CamcorderProfile recordingProfile,
+      @NonNull CamcorderProfile camcorderProfile,
       @NonNull String outputFilePath,
       MediaRecorderFactory helper) {
     this.outputFilePath = outputFilePath;
-    this.recordingProfile = recordingProfile;
+    this.camcorderProfile = camcorderProfile;
+    this.encoderProfiles = null;
+    this.recorderFactory = helper;
+  }
+
+  MediaRecorderBuilder(
+      @NonNull EncoderProfiles encoderProfiles,
+      @NonNull String outputFilePath,
+      MediaRecorderFactory helper) {
+    this.outputFilePath = outputFilePath;
+    this.encoderProfiles = encoderProfiles;
+    this.camcorderProfile = null;
     this.recorderFactory = helper;
   }
 
@@ -47,23 +67,43 @@ public MediaRecorderBuilder setMediaOrientation(int orientation) {
     return this;
   }
 
-  public MediaRecorder build() throws IOException {
+  public MediaRecorder build() throws IOException, NullPointerException, IndexOutOfBoundsException {
     MediaRecorder mediaRecorder = recorderFactory.makeMediaRecorder();
 
     // There's a fixed order that mediaRecorder expects. Only change these functions accordingly.
     // You can find the specifics here: https://developer.android.com/reference/android/media/MediaRecorder.
     if (enableAudio) mediaRecorder.setAudioSource(MediaRecorder.AudioSource.MIC);
     mediaRecorder.setVideoSource(MediaRecorder.VideoSource.SURFACE);
-    mediaRecorder.setOutputFormat(recordingProfile.fileFormat);
-    if (enableAudio) {
-      mediaRecorder.setAudioEncoder(recordingProfile.audioCodec);
-      mediaRecorder.setAudioEncodingBitRate(recordingProfile.audioBitRate);
-      mediaRecorder.setAudioSamplingRate(recordingProfile.audioSampleRate);
+
+    if (Build.VERSION.SDK_INT >= 31) {
+      EncoderProfiles.VideoProfile videoProfile = encoderProfiles.getVideoProfiles().get(0);
+      EncoderProfiles.AudioProfile audioProfile = encoderProfiles.getAudioProfiles().get(0);
+
+      mediaRecorder.setOutputFormat(encoderProfiles.getRecommendedFileFormat());
+      if (enableAudio) {
+        mediaRecorder.setAudioEncoder(audioProfile.getCodec());
+        mediaRecorder.setAudioEncodingBitRate(audioProfile.getBitrate());
+        mediaRecorder.setAudioSamplingRate(audioProfile.getSampleRate());
+      }
+      mediaRecorder.setVideoEncoder(videoProfile.getCodec());
+      mediaRecorder.setVideoEncodingBitRate(videoProfile.getBitrate());
+      mediaRecorder.setVideoFrameRate(videoProfile.getFrameRate());
+      mediaRecorder.setVideoSize(videoProfile.getWidth(), videoProfile.getHeight());
+      mediaRecorder.setVideoSize(videoProfile.getWidth(), videoProfile.getHeight());
+    } else {
+      mediaRecorder.setOutputFormat(camcorderProfile.fileFormat);
+      if (enableAudio) {
+        mediaRecorder.setAudioEncoder(camcorderProfile.audioCodec);
+        mediaRecorder.setAudioEncodingBitRate(camcorderProfile.audioBitRate);
+        mediaRecorder.setAudioSamplingRate(camcorderProfile.audioSampleRate);
+      }
+      mediaRecorder.setVideoEncoder(camcorderProfile.videoCodec);
+      mediaRecorder.setVideoEncodingBitRate(camcorderProfile.videoBitRate);
+      mediaRecorder.setVideoFrameRate(camcorderProfile.videoFrameRate);
+      mediaRecorder.setVideoSize(
+          camcorderProfile.videoFrameWidth, camcorderProfile.videoFrameHeight);
     }
-    mediaRecorder.setVideoEncoder(recordingProfile.videoCodec);
-    mediaRecorder.setVideoEncodingBitRate(recordingProfile.videoBitRate);
-    mediaRecorder.setVideoFrameRate(recordingProfile.videoFrameRate);
-    mediaRecorder.setVideoSize(recordingProfile.videoFrameWidth, recordingProfile.videoFrameHeight);
+
     mediaRecorder.setOutputFile(outputFilePath);
     mediaRecorder.setOrientationHint(this.mediaOrientation);