[camera_web] Re: Support for camera stream on web

packages/camera/camera_web/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.3.6
+
+* Adds support for camera image stream on web.
+
 ## 0.3.5+5
 
 * Removes invalid @JS annotation from extension type constructors.

packages/camera/camera_web/example/integration_test/camera_error_code_test.dart

@@ -76,13 +76,43 @@ void main() {
         expect(CameraErrorCode.notStarted.toString(), equals('cameraNotStarted'));
       });
 
+      testWidgets('noVideoTrack', (WidgetTester tester) async {
+        expect(CameraErrorCode.noVideoTrack.toString(), equals('noVideoTrack'));
+      });
+
+      testWidgets('cameraFrameDimensionsZero', (WidgetTester tester) async {
+        expect(
+          CameraErrorCode.cameraFrameDimensionsZero.toString(),
+          equals('cameraFrameDimensionsZero'),
+        );
+      });
+
+      testWidgets('videoTrackReaderClosed', (WidgetTester tester) async {
+        expect(CameraErrorCode.videoTrackReaderClosed.toString(), equals('videoTrackReaderClosed'));
+      });
+
+      testWidgets('videoTrackReaderNotInitialized', (WidgetTester tester) async {
+        expect(
+          CameraErrorCode.videoTrackReaderNotInitialized.toString(),
+          equals('videoTrackReaderNotInitialized'),
+        );
+      });
+
       testWidgets('videoRecordingNotStarted', (WidgetTester tester) async {
         expect(
           CameraErrorCode.videoRecordingNotStarted.toString(),
           equals('videoRecordingNotStarted'),
         );
       });
 
+      testWidgets('missingPlaneLayout', (WidgetTester tester) async {
+        expect(CameraErrorCode.missingPlaneLayout.toString(), equals('missingPlaneLayout'));
+      });
+
+      testWidgets('unableToCloneFrame', (WidgetTester tester) async {
+        expect(CameraErrorCode.unableToCloneFrame.toString(), equals('unableToCloneFrame'));
+      });
+
       testWidgets('unknown', (WidgetTester tester) async {
         expect(CameraErrorCode.unknown.toString(), equals('cameraUnknown'));
       });

packages/camera/camera_web/example/integration_test/camera_service_test.dart

@@ -4,6 +4,7 @@
 
 // ignore_for_file: only_throw_errors
 
+import 'dart:async';
 import 'dart:js_interop';
 import 'dart:js_interop_unsafe';
 
@@ -793,5 +794,292 @@ void main() {
         );
       });
     });
+
+    group('hasMediaStreamTrackProcessor', () {
+      setUp(() {
+        cameraService.jsUtil = jsUtil;
+      });
+
+      testWidgets('returns true if broswer has MediaStreamTrackProcessor '
+          'otherwise false', (WidgetTester widgetTester) async {
+        for (final supportsMediaStreamTrackProcessor in <bool>[true, false]) {
+          when(
+            jsUtil.hasProperty(window, 'MediaStreamTrackProcessor'.toJS),
+          ).thenReturn(supportsMediaStreamTrackProcessor);
+
+          final bool hasMediaStreamTrackProcessor = cameraService.hasMediaStreamTrackProcessor();
+
+          expect(
+            hasMediaStreamTrackProcessor,
+            supportsMediaStreamTrackProcessor ? isTrue : isFalse,
+          );
+        }
+      });
+    });
+
+    group('getMediaStreamVideoTrack', () {
+      testWidgets('returns the first video track when tracks exist in the stream', (
+        WidgetTester widgetTester,
+      ) async {
+        final web.MediaStream mockStream = getVideoElementWithBlankStream(
+          const Size(10, 10),
+        ).captureStream();
+
+        final web.MediaStreamTrack track = cameraService.getMediaStreamVideoTrack(mockStream);
+
+        expect(track, isNotNull);
+      });
+
+      testWidgets('throw CameraWebException when no video tracks are found', (
+        WidgetTester widgetTester,
+      ) async {
+        final mockStream = createJSInteropWrapper(FakeMediaStream([])) as web.MediaStream;
+
+        expect(
+          () => cameraService.getMediaStreamVideoTrack(mockStream, cameraId: 42),
+          throwsA(
+            isA<CameraWebException>().having((e) => e.code, 'code', CameraErrorCode.noVideoTrack),
+          ),
+        );
+      });
+    });
+
+    group('getMediaStreamTrackReader', () {
+      testWidgets('returns ReadableStreamDefaultReader of MediaStreamTrack', (
+        WidgetTester tester,
+      ) async {
+        final web.MediaStreamTrack mediaStreamTrack = getVideoElementWithBlankStream(
+          const Size(10, 10),
+        ).captureStream().getTracks().toDart.first;
+
+        final web.ReadableStreamDefaultReader readableStreamDefaultReader = cameraService
+            .getMediaStreamTrackReader(mediaStreamTrack);
+
+        expect(
+          readableStreamDefaultReader.read().toDart,
+          isA<Future<web.ReadableStreamReadResult>>(),
+        );
+        mediaStreamTrack.stop();
+      });
+    });
+
+    group('readVideoTrack', () {
+      setUp(() {
+        cameraService.isVideoFrameType = (_) => true;
+      });
+
+      web.ReadableStreamDefaultReader mockMediaTrackReader({
+        MockVideoFrame? mockFrame,
+        bool done = false,
+      }) {
+        final mockReader = MockReadableStreamDefaultReader();
+        mockReader.read = (() => Future.value(
+          web.ReadableStreamReadResult(
+            done: done,
+            value: mockFrame == null ? null : createJSInteropWrapper(mockFrame) as JSAny,
+          ),
+        ).toJS).toJS;
+        return createJSInteropWrapper(mockReader) as web.ReadableStreamDefaultReader;
+      }
+
+      testWidgets('returns VideoFrame from ReadableStreamDefaultReader', (
+        WidgetTester widgetTester,
+      ) async {
+        final mockFrame = MockVideoFrame(width: 10, height: 10, bufferSize: 32);
+        final web.ReadableStreamDefaultReader mockReader = mockMediaTrackReader(
+          mockFrame: mockFrame,
+        );
+
+        final web.VideoFrame videoFrame = await cameraService.readVideoTrack(mockReader);
+
+        expect(videoFrame.visibleRect, equals(mockFrame.visibleRect));
+        expect(
+          videoFrame.allocationSize(web.VideoFrameCopyToOptions()),
+          equals(mockFrame.bufferSize),
+        );
+        expect(videoFrame.format, equals(mockFrame.format));
+      });
+
+      void expectReadVideoFrameException({
+        required web.ReadableStreamDefaultReader reader,
+        required CameraErrorCode errorCode,
+      }) {
+        expect(
+          () => cameraService.readVideoTrack(reader),
+          throwsA(
+            isA<CameraWebException>().having((CameraWebException e) => e.code, 'code', errorCode),
+          ),
+        );
+      }
+
+      testWidgets('throws CameraWebException if the video track reader is closed', (
+        WidgetTester tester,
+      ) async {
+        final web.ReadableStreamDefaultReader mockReader = mockMediaTrackReader(done: true);
+
+        expectReadVideoFrameException(
+          reader: mockReader,
+          errorCode: CameraErrorCode.videoTrackReaderClosed,
+        );
+      });
+
+      testWidgets('throws CameraWebException if the video track reader is not initialized', (
+        WidgetTester tester,
+      ) async {
+        final mockFrame = MockVideoFrame(width: 0, height: 0, bufferSize: 0)..visibleRect = null;
+        final web.ReadableStreamDefaultReader mockReader = mockMediaTrackReader(
+          mockFrame: mockFrame,
+        );
+
+        expectReadVideoFrameException(
+          reader: mockReader,
+          errorCode: CameraErrorCode.videoTrackReaderNotInitialized,
+        );
+      });
+    });
+
+    group('copyVideoFrameToBufferAndGetStride', () {
+      web.VideoFrame stubVideoFrameCopyTo(JSPromise<JSArray<web.PlaneLayout>> Function() result) {
+        final mockFrame = MockVideoFrame(width: 10, height: 10, bufferSize: 32);
+        mockFrame.copyTo = (JSAny? destination, web.VideoFrameCopyToOptions options) => result();
+        return createJSInteropWrapper(mockFrame) as web.VideoFrame;
+      }
+
+      testWidgets('returns first plane stride', (WidgetTester tester) async {
+        const expectedStride = 640;
+        final web.VideoFrame videoFrame = stubVideoFrameCopyTo(
+          () => Future<JSArray<web.PlaneLayout>>.value(
+            JSArray<web.PlaneLayout>()..add(web.PlaneLayout(offset: 0, stride: expectedStride)),
+          ).toJS,
+        );
+
+        final int stride = await cameraService.copyVideoFrameToBufferAndGetStride(
+          videoFrame,
+          destination: JSUint8Array.withLength(100),
+          copyOptions: web.VideoFrameCopyToOptions(),
+        );
+
+        expect(stride, expectedStride);
+      });
+
+      void expectCameraWebException(web.VideoFrame videoFrame, CameraErrorCode code) {
+        expect(
+          () => cameraService.copyVideoFrameToBufferAndGetStride(
+            videoFrame,
+            destination: JSUint8Array.withLength(100),
+            copyOptions: web.VideoFrameCopyToOptions(),
+          ),
+          throwsA(isA<CameraWebException>().having((CameraWebException e) => e.code, 'code', code)),
+        );
+      }
+
+      testWidgets('throws missingPlaneLayout when browser returns no planes', (
+        WidgetTester tester,
+      ) async {
+        final web.VideoFrame videoFrame = stubVideoFrameCopyTo(
+          () => Future<JSArray<web.PlaneLayout>>.value(JSArray<web.PlaneLayout>()).toJS,
+        );
+
+        expectCameraWebException(videoFrame, CameraErrorCode.missingPlaneLayout);
+      });
+
+      testWidgets('throws unableToCloneFrame when DOMException occurs', (
+        WidgetTester tester,
+      ) async {
+        final web.VideoFrame videoFrame = stubVideoFrameCopyTo(
+          () => throw web.DOMException('Frame is corrupted', 'InvalidStateError'),
+        );
+
+        expectCameraWebException(videoFrame, CameraErrorCode.unableToCloneFrame);
+      });
+    });
+
+    group('getCameraImageData', () {
+      testWidgets('returns CameraImageData with valid planes', (WidgetTester tester) async {
+        const mockWidth = 2;
+        const mockHeight = 2;
+        final mockBytes = Uint8List(mockWidth * mockHeight * 4);
+
+        final CameraImageData cameraImageData = cameraService.getCameraImageData(
+          width: mockWidth,
+          height: mockHeight,
+          bytes: mockBytes,
+          bytesPerRow: mockWidth * 4,
+        );
+
+        expect(cameraImageData.width, equals(mockWidth));
+        expect(cameraImageData.height, equals(mockHeight));
+
+        expect(cameraImageData.format.group, equals(ImageFormatGroup.unknown));
+        expect(cameraImageData.format.raw, equals('rgba8888'));
+
+        expect(cameraImageData.planes.length, equals(1));
+        final CameraImagePlane plane = cameraImageData.planes.first;
+
+        expect(plane.width, equals(mockWidth));
+        expect(plane.height, equals(mockHeight));
+        expect(plane.bytesPerPixel, equals(4));
+        expect(plane.bytesPerRow, equals(mockWidth * 4));
+        expect(plane.bytes, equals(mockBytes));
+      });
+    });
+
+    group('hasPropertyOffScreenCanvas', () {
+      setUp(() {
+        cameraService.jsUtil = jsUtil;
+      });
+      testWidgets('hasPropertyOffScreenCanvas returns true if broswer has OffscreenCanvas '
+          'otherwise false', (WidgetTester widgetTester) async {
+        for (final supportsOffscreenCanvas in <bool>[true, false]) {
+          when(
+            jsUtil.hasProperty(window, 'OffscreenCanvas'.toJS),
+          ).thenReturn(supportsOffscreenCanvas);
+          final bool hasOffScreenCanvas = cameraService.hasPropertyOffScreenCanvas();
+          expect(hasOffScreenCanvas, supportsOffscreenCanvas ? isTrue : isFalse);
+        }
+      });
+    });
+
+    group('takeFrame', () {
+      testWidgets('returns Camera Image of Size '
+          'when videoElement is of Size '
+          'regardless of OffscreenCanvas support', (WidgetTester widgetTester) async {
+        const size = Size(10, 10);
+        final completer = Completer<void>();
+        final web.VideoElement videoElement = getVideoElementWithBlankStream(size)
+          ..onLoadedMetadata.listen((_) {
+            completer.complete();
+          })
+          ..load();
+        await completer.future;
+
+        for (final supportsOffscreenCanvas in <bool>[true, false]) {
+          when(
+            jsUtil.hasProperty(window, 'OffscreenCanvas'.toJS),
+          ).thenReturn(supportsOffscreenCanvas);
+
+          final CameraImageData cameraImageData = cameraService.takeFrame(videoElement);
+
+          expect(size, Size(cameraImageData.width.toDouble(), cameraImageData.height.toDouble()));
+        }
+      });
+
+      testWidgets('throws CameraWebException when video element not loaded', (
+        WidgetTester widgetTester,
+      ) async {
+        final web.VideoElement videoElement = getVideoElementWithBlankStream(const Size(10, 10));
+
+        expect(
+          () => cameraService.takeFrame(videoElement),
+          throwsA(
+            isA<CameraWebException>().having(
+              (CameraWebException e) => e.code,
+              'code',
+              CameraErrorCode.cameraFrameDimensionsZero,
+            ),
+          ),
+        );
+      });
+    });
   });
 }