Android implementation works

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

@@ -606,7 +606,16 @@ public void startVideoRecording(Result result, Integer maxVideoDuration) {
      if(maxVideoDuration != null) {
        mediaRecorder.setOnInfoListener((mr, what, extra) -> {
          if (what == MEDIA_RECORDER_INFO_MAX_DURATION_REACHED) {
-           dartMessenger.sendTimeLimitReachedEvent(videoRecordingFile.getPath());
+           try {
+             dartMessenger.sendTimeLimitReachedEvent(videoRecordingFile.getAbsolutePath());
+             cameraCaptureSession.abortCaptures();
+             mediaRecorder.stop();
+             recordingVideo = false;
+             videoRecordingFile = null;
+             startPreview();
+           } catch (CameraAccessException e) {
+             // Ignore exceptions and try to continue (changes are camera session already aborted capture)
+           }
          }
        });
      }

packages/camera/camera/example/lib/main.dart

@@ -607,8 +607,13 @@ class _CameraExampleHomeState extends State<CameraExampleHome>
 
     try {
       await controller.startVideoRecording(
-          maxVideoDuration: null //const Duration(milliseconds: 5000),
+          maxVideoDuration: const Duration(milliseconds: 5000),
       );
+      debugPrint('recording started');
+      controller.onCameraTimeLimitReachedEvent(onCameraTimeLimitReached: (file) {
+        debugPrint('onCameraTimeLimitReached ${file.path}');
+      });
+      debugPrint('listening');
     } on CameraException catch (e) {
       _showCameraException(e);
       return;

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

@@ -381,7 +381,9 @@ class CameraController extends ValueNotifier<CameraValue> {
   ///
   /// The video is returned as a [XFile] after calling [stopVideoRecording].
   /// Throws a [CameraException] if the capture fails.
-  Future<XFile> startVideoRecording({Duration maxVideoDuration}) async {
+  ///
+  /// TODO: Documentation: when maxVideoDuration listen to Stream with CameraTimeLimitReachedEvent
+  Future<void> startVideoRecording({Duration maxVideoDuration}) async {
     if (!value.isInitialized || _isDisposed) {
       throw CameraException(
         'Uninitialized CameraController',
@@ -402,24 +404,9 @@ class CameraController extends ValueNotifier<CameraValue> {
     }
 
     try {
-      Completer<XFile> completer = Completer();
       await CameraPlatform.instance
           .startVideoRecording(_cameraId, maxVideoDuration: maxVideoDuration);
       value = value.copyWith(isRecordingVideo: true, isRecordingPaused: false);
-
-      if (maxVideoDuration != null) {
-        await CameraPlatform.instance
-            .onCameraTimeLimitReached(_cameraId)
-            .listen((event) {
-          debugPrint('Video recorded to: ${event.path}');
-          completer.complete(XFile(event.path));
-          value =
-              value.copyWith(isRecordingVideo: false, isRecordingPaused: false);
-        });
-        return completer.future;
-      } else {
-        return null;
-      }
     } on PlatformException catch (e) {
       throw CameraException(e.code, e.message);
     }
@@ -498,6 +485,32 @@ class CameraController extends ValueNotifier<CameraValue> {
     }
   }
 
+  /// TODO: Documentation
+  void onCameraTimeLimitReachedEvent({onCameraTimeLimitReached}) {
+    if (!value.isInitialized || _isDisposed) {
+      throw CameraException(
+        'Uninitialized CameraController',
+        'cameraTimeLimitReachedEventStream was called on uninitialized CameraController',
+      );
+    }
+    if (!value.isRecordingVideo) {
+      throw CameraException(
+        'No video is recording',
+        'cameraTimeLimitReachedEventStream was called when no video is recording.',
+      );
+    }
+    debugPrint('ping');
+
+    CameraPlatform.instance.onCameraTimeLimitReached(_cameraId).listen((event) {
+      debugPrint('onCameraTimeLimitReached');
+      value = value.copyWith(isRecordingVideo: false);
+      onCameraTimeLimitReached(event.path);
+    });
+
+    debugPrint('pong');
+    return;
+  }
+
   /// Returns a widget showing a live camera preview.
   Widget buildPreview() {
     if (!value.isInitialized || _isDisposed) {

packages/camera/camera_platform_interface/lib/src/events/camera_event.dart

@@ -237,21 +237,21 @@ class CameraErrorEvent extends CameraEvent {
 }
 
 class CameraTimeLimitReachedEvent extends CameraEvent {
-  final String path;
+  final XFile path;
 
   CameraTimeLimitReachedEvent(int cameraId, this.path) : super(cameraId);
 
   /// Converts the supplied [Map] to an instance of the [CameraTimeLimitReachedEvent]
   /// class.
   CameraTimeLimitReachedEvent.fromJson(Map<String, dynamic> json)
-      : path = json['path'],
+      : path = XFile(json['path']),
         super(json['cameraId']);
 
   /// Converts the [CameraTimeLimitReachedEvent] instance into a [Map] instance that can be
   /// serialized to JSON.
   Map<String, dynamic> toJson() => {
     'cameraId': cameraId,
-    'path': path,
+    'path': path.path,
   };
 
   @override

packages/camera/camera_platform_interface/lib/src/method_channel/method_channel_camera.dart

@@ -162,6 +162,11 @@ class MethodChannelCamera extends CameraPlatform {
         .whereType<DeviceOrientationChangedEvent>();
   }
 
+  @override
+  Stream<CameraTimeLimitReachedEvent> onCameraTimeLimitReached(int cameraId) {
+    return _cameraEvents(cameraId).whereType<CameraTimeLimitReachedEvent>();
+  }
+
   @override
   Future<void> lockCaptureOrientation(
       int cameraId, DeviceOrientation orientation) async {
@@ -182,11 +187,6 @@ class MethodChannelCamera extends CameraPlatform {
     );
   }
 
-  @override
-  Stream<CameraTimeLimitReachedEvent> onCameraTimeLimitReached(int cameraId) {
-    return _cameraEvents(cameraId).whereType<CameraTimeLimitReachedEvent>();
-  }
-
   @override
   Future<XFile> takePicture(int cameraId) async {
     String path = await _channel.invokeMethod<String>(
@@ -210,12 +210,6 @@ class MethodChannelCamera extends CameraPlatform {
         'maxVideoDuration': maxVideoDuration?.inMilliseconds,
       },
     );
-
-    if (maxVideoDuration != null) {
-      await onCameraTimeLimitReached(cameraId).first.then((value) {
-        debugPrint('received event');
-      });
-    }
   }
 
   @override
@@ -435,7 +429,7 @@ class MethodChannelCamera extends CameraPlatform {
       case 'max_time_limit_reached':
         cameraEventStreamController.add(CameraTimeLimitReachedEvent(
           cameraId,
-          call.arguments['path'],
+          XFile(call.arguments['path']),
         ));
         break;
       case 'resolution_changed':