[camera_android_camerax] Implement setDescriptionWhileRecording

packages/camera/camera/CHANGELOG.md

@@ -1,5 +1,6 @@
-## NEXT
+## 0.11.2+1
 
+* Fixes flutter/flutter#148013: setDescriptionWhileRecording with android camerax.
 * Updates minimum supported SDK version to Flutter 3.29/Dart 3.7.
 
 ## 0.11.2

packages/camera/camera/example/integration_test/camera_test.dart

@@ -275,7 +275,9 @@ void main() {
     await controller.initialize();
     await controller.prepareForVideoRecording();
 
-    await controller.startVideoRecording();
+    await controller.startVideoRecording(
+      enableAndroidPersistentRecording: true,
+    );
     await controller.setDescription(cameras[1]);
 
     expect(controller.description, cameras[1]);

packages/camera/camera/example/pubspec.yaml

@@ -31,3 +31,8 @@ dev_dependencies:
 
 flutter:
   uses-material-design: true
+# FOR TESTING AND INITIAL REVIEW ONLY. DO NOT MERGE.
+# See https://github.com/flutter/flutter/blob/master/docs/ecosystem/contributing/README.md#changing-federated-plugins
+dependency_overrides:
+  camera_android_camerax: {path: ../../../../packages/camera/camera_android_camerax}
+  camera_platform_interface: {path: ../../../../packages/camera/camera_platform_interface}

packages/camera/camera/lib/src/camera_controller.dart

@@ -439,6 +439,12 @@ class CameraController extends ValueNotifier<CameraValue> {
 
   /// Sets the description of the camera.
   ///
+  /// By default, if a video recording is in progress, calling this method will cancel the current recording on Android.
+  ///
+  /// To keep recording active while switching cameras on Android, start the
+  /// recording with [startVideoRecording] and set
+  /// `enableAndroidPersistentRecording` to `true`.
+  ///
   /// Throws a [CameraException] if setting the description fails.
   Future<void> setDescription(CameraDescription description) async {
     if (value.isRecordingVideo) {
@@ -554,8 +560,15 @@ class CameraController extends ValueNotifier<CameraValue> {
   ///
   /// The video is returned as a [XFile] after calling [stopVideoRecording].
   /// Throws a [CameraException] if the capture fails.
+  ///
+  /// The [enableAndroidPersistentRecording] parameter is only available on Android.
+  /// If set to true, configures the recording to be a persistent recording.
+  /// A persistent recording will only be stopped by explicitly calling [stopVideoRecording]
+  /// and will ignore events that would normally cause recording to stop,
+  /// such as lifecycle events or explicit calls to [setDescription] while recording is in progress.
   Future<void> startVideoRecording({
     onLatestImageAvailable? onAvailable,
+    bool enableAndroidPersistentRecording = false,
   }) async {
     _throwIfNotInitialized('startVideoRecording');
     if (value.isRecordingVideo) {
@@ -574,7 +587,11 @@ class CameraController extends ValueNotifier<CameraValue> {
 
     try {
       await CameraPlatform.instance.startVideoCapturing(
-        VideoCaptureOptions(_cameraId, streamCallback: streamCallback),
+        VideoCaptureOptions(
+          _cameraId,
+          streamCallback: streamCallback,
+          enableAndroidPersistentRecording: enableAndroidPersistentRecording,
+        ),
       );
       value = value.copyWith(
         isRecordingVideo: true,

packages/camera/camera/pubspec.yaml

@@ -4,7 +4,7 @@ description: A Flutter plugin for controlling the camera. Supports previewing
   Dart.
 repository: https://github.com/flutter/packages/tree/main/packages/camera/camera
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+camera%22
-version: 0.11.2
+version: 0.11.2+1
 
 environment:
   sdk: ^3.7.0
@@ -38,3 +38,8 @@ dev_dependencies:
 
 topics:
   - camera
+# FOR TESTING AND INITIAL REVIEW ONLY. DO NOT MERGE.
+# See https://github.com/flutter/flutter/blob/master/docs/ecosystem/contributing/README.md#changing-federated-plugins
+dependency_overrides:
+  camera_android_camerax: {path: ../../../packages/camera/camera_android_camerax}
+  camera_platform_interface: {path: ../../../packages/camera/camera_platform_interface}

packages/camera/camera/test/camera_preview_test.dart

@@ -111,6 +111,7 @@ class FakeController extends ValueNotifier<CameraValue>
   @override
   Future<void> startVideoRecording({
     onLatestImageAvailable? onAvailable,
+    bool enableAndroidPersistentRecording = false,
   }) async {}
 
   @override

packages/camera/camera_android/example/pubspec.yaml

@@ -31,3 +31,7 @@ dev_dependencies:
 
 flutter:
   uses-material-design: true
+# FOR TESTING AND INITIAL REVIEW ONLY. DO NOT MERGE.
+# See https://github.com/flutter/flutter/blob/master/docs/ecosystem/contributing/README.md#changing-federated-plugins
+dependency_overrides:
+  camera_platform_interface: {path: ../../../../packages/camera/camera_platform_interface}

packages/camera/camera_android_camerax/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.6.22
+
+* Implements `setDescriptionWhileRecording`.
+
 ## 0.6.21
 
 * Implements NV21 support for image streaming.

packages/camera/camera_android_camerax/README.md

@@ -34,10 +34,6 @@ use cases, the plugin behaves according to the following:
     video recording and image streaming is supported, but concurrent video recording, image
     streaming, and image capture is not supported.
 
-### `setDescriptionWhileRecording` is unimplemented [Issue #148013][148013]
-`setDescriptionWhileRecording`, used to switch cameras while recording video, is currently unimplemented
-due to this not currently being supported by CameraX.
-
 ### 240p resolution configuration for video recording
 
 240p resolution configuration for video recording is unsupported by CameraX, and thus,

packages/camera/camera_android_camerax/android/src/main/java/io/flutter/plugins/camerax/CameraXLibrary.g.kt

@@ -3652,6 +3652,22 @@ abstract class PigeonApiPendingRecording(
       initialMuted: Boolean
   ): androidx.camera.video.PendingRecording
 
+  /**
+   * Configures the recording to be a persistent recording.
+   *
+   * A persistent recording will only be stopped by explicitly calling [Recording.stop] or
+   * [Recording.close] and will ignore events that would normally cause recording to stop, such as
+   * lifecycle events or explicit unbinding of a [VideoCapture] use case that the recording's
+   * Recorder is attached to.
+   *
+   * To switch to a different camera stream while a recording is in progress, first create the
+   * recording as persistent recording, then rebind the [VideoCapture] it's associated with to a
+   * different camera.
+   */
+  abstract fun asPersistentRecording(
+      pigeon_instance: androidx.camera.video.PendingRecording
+  ): androidx.camera.video.PendingRecording
+
   /** Starts the recording, making it an active recording. */
   abstract fun start(
       pigeon_instance: androidx.camera.video.PendingRecording,
@@ -3685,6 +3701,28 @@ abstract class PigeonApiPendingRecording(
           channel.setMessageHandler(null)
         }
       }
+      run {
+        val channel =
+            BasicMessageChannel<Any?>(
+                binaryMessenger,
+                "dev.flutter.pigeon.camera_android_camerax.PendingRecording.asPersistentRecording",
+                codec)
+        if (api != null) {
+          channel.setMessageHandler { message, reply ->
+            val args = message as List<Any?>
+            val pigeon_instanceArg = args[0] as androidx.camera.video.PendingRecording
+            val wrapped: List<Any?> =
+                try {
+                  listOf(api.asPersistentRecording(pigeon_instanceArg))
+                } catch (exception: Throwable) {
+                  CameraXLibraryPigeonUtils.wrapError(exception)
+                }
+            reply.reply(wrapped)
+          }
+        } else {
+          channel.setMessageHandler(null)
+        }
+      }
       run {
         val channel =
             BasicMessageChannel<Any?>(

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

@@ -7,6 +7,7 @@
 import android.Manifest;
 import android.content.pm.PackageManager;
 import androidx.annotation.NonNull;
+import androidx.camera.video.ExperimentalPersistentRecording;
 import androidx.camera.video.PendingRecording;
 import androidx.camera.video.Recording;
 import androidx.core.content.ContextCompat;
@@ -27,6 +28,13 @@ public ProxyApiRegistrar getPigeonRegistrar() {
     return (ProxyApiRegistrar) super.getPigeonRegistrar();
   }
 
+  @ExperimentalPersistentRecording
+  @NonNull
+  @Override
+  public PendingRecording asPersistentRecording(PendingRecording pigeonInstance) {
+    return pigeonInstance.asPersistentRecording();
+  }
+
   @NonNull
   @Override
   public PendingRecording withAudioEnabled(PendingRecording pigeonInstance, boolean initialMuted) {

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

@@ -83,6 +83,19 @@ public void withAudioEnabled_doesNotEnableAudioWhenAudioNotRequested() {
     verify(instance).withAudioEnabled(true);
   }
 
+  @Test
+  public void asPersistentRecording_returnsPersistentRecordingInstance() {
+    final PigeonApiPendingRecording api =
+        new TestProxyApiRegistrar().getPigeonApiPendingRecording();
+    final PendingRecording instance = mock(PendingRecording.class);
+    final PendingRecording persistentInstance = mock(PendingRecording.class);
+
+    when(instance.asPersistentRecording()).thenReturn(persistentInstance);
+
+    assertEquals(persistentInstance, api.asPersistentRecording(instance));
+    verify(instance).asPersistentRecording();
+  }
+
   @Test
   public void start_callsStartOnInstance() {
     final PigeonApiPendingRecording api =

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

@@ -226,4 +226,62 @@ void main() {
 
     expect(duration, lessThan(recordingTime - timePaused));
   }, skip: skipFor157181);
+
+  testWidgets('Switch camera while recording captures full video', (
+    WidgetTester tester,
+  ) async {
+    final List<CameraDescription> cameras = await availableCameras();
+    if (cameras.isEmpty) {
+      return;
+    }
+
+    final CameraController controller = CameraController(
+      cameras[0],
+      mediaSettings: const MediaSettings(
+        resolutionPreset: ResolutionPreset.medium,
+      ),
+    );
+    await controller.initialize();
+    await controller.prepareForVideoRecording();
+
+    await controller.startVideoRecording(enablePersistentRecording: true);
+
+    sleep(const Duration(seconds: 2));
+
+    await controller.setDescription(
+      cameras.firstWhere(
+        (CameraDescription description) =>
+            description != controller.description,
+        orElse: () => cameras.first,
+      ),
+    );
+
+    sleep(const Duration(seconds: 1));
+
+    await controller.setDescription(
+      cameras.firstWhere(
+        (CameraDescription description) =>
+            description != controller.description,
+        orElse: () => cameras.first,
+      ),
+    );
+
+    sleep(const Duration(seconds: 1));
+
+    final XFile file = await controller.stopVideoRecording();
+
+    final File videoFile = File(file.path);
+    final VideoPlayerController videoController = VideoPlayerController.file(
+      videoFile,
+    );
+    await videoController.initialize();
+    final int duration = videoController.value.duration.inMilliseconds;
+    await videoController.dispose();
+
+    expect(
+      duration,
+      greaterThanOrEqualTo(const Duration(seconds: 4).inMilliseconds),
+    );
+    await controller.dispose();
+  }, skip: skipFor157181);
 }