Skip to content

armgit / ente

Public Imported from GitHub
0

πŸ’š End-to-end encrypted cloud for everything.

[mob][photos] Replace Chewie with native playback for external videos

ashil-pilot5f06bbe3c96c
diff --git a/mobile/apps/photos/integration_test/external_video_viewer_test.dart b/mobile/apps/photos/integration_test/external_video_viewer_test.dart
new file mode 100644
index 0000000000..b00b4e2abc
--- /dev/null
+++ b/mobile/apps/photos/integration_test/external_video_viewer_test.dart
@@ -0,0 +1,373 @@
+import "dart:async";
+import "dart:convert";
+import "dart:io";
+import "dart:typed_data";
+
+import "package:flutter/material.dart";
+import "package:flutter_test/flutter_test.dart";
+import "package:integration_test/integration_test.dart";
+import "package:native_video_player/native_video_player.dart";
+import "package:path_provider/path_provider.dart";
+import "package:photo_manager/photo_manager.dart";
+import "package:photos/ui/viewer/file/external_video_viewer.dart";
+import "package:photos/ui/viewer/file/native_video_player_controls/play_pause_button.dart";
+
+void main() {
+ IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+ late File videoFile;
+
+ setUp(() async {
+ final directory = await getTemporaryDirectory();
+ videoFile = File("${directory.path}/external_video_viewer_test.mp4");
+ await videoFile.writeAsBytes(base64Decode(_portraitVideo));
+ });
+
+ tearDown(() async {
+ if (await videoFile.exists()) await videoFile.delete();
+ });
+
+ testWidgets("shared file controls, looping, lifecycle, and fullscreen", (
+ tester,
+ ) async {
+ final state = await _openVideo(tester, videoFile.path);
+ final controller = state.controller!;
+ expect(controller.videoInfo!.width, 320);
+ expect(controller.videoInfo!.height, 640);
+ final videoSize = tester.getSize(find.byType(NativeVideoPlayerView));
+ expect(videoSize.width / videoSize.height, closeTo(0.5, 0.01));
+
+ await _showControls(tester);
+ await tester.tap(find.byType(PlayPauseButton));
+ await _pumpUntil(
+ tester,
+ () => controller.playbackStatus == PlaybackStatus.paused,
+ );
+ await tester.tap(find.byIcon(Icons.volume_up));
+ await _pumpUntil(tester, () => controller.volume == 0);
+ expect(find.byIcon(Icons.volume_off), findsOneWidget);
+
+ tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.paused);
+ await tester.runAsync(
+ () => Future<void>.delayed(const Duration(milliseconds: 100)),
+ );
+ tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.resumed);
+ await tester.pump(const Duration(milliseconds: 300));
+ expect(controller.playbackStatus, PlaybackStatus.paused);
+
+ final slider = tester.getRect(find.byType(Slider));
+ await tester.tapAt(
+ Offset(slider.left + slider.width * 0.75, slider.center.dy),
+ );
+ await _pumpUntil(
+ tester,
+ () => controller.playbackPosition >= const Duration(seconds: 2),
+ );
+ expect(controller.playbackStatus, PlaybackStatus.paused);
+
+ var reachedEnd = false;
+ final endingSubscription = controller.events.listen((event) {
+ if (event is PlaybackEndedEvent) reachedEnd = true;
+ });
+ await controller.seekTo(const Duration(milliseconds: 3500));
+ await _pumpUntil(
+ tester,
+ () => controller.playbackPosition >= const Duration(seconds: 3),
+ );
+ await tester.tap(find.byType(PlayPauseButton));
+ await _pumpUntil(
+ tester,
+ () =>
+ reachedEnd &&
+ controller.playbackStatus == PlaybackStatus.playing &&
+ controller.playbackPosition < const Duration(seconds: 1),
+ );
+ await endingSubscription.cancel();
+
+ tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.paused);
+ await _pumpUntil(
+ tester,
+ () => controller.playbackStatus == PlaybackStatus.paused,
+ );
+ tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.resumed);
+ await _pumpUntil(
+ tester,
+ () => controller.playbackStatus == PlaybackStatus.playing,
+ );
+
+ await _showControls(tester);
+ await tester.tap(find.byIcon(Icons.fullscreen));
+ await _pumpUntil(
+ tester,
+ () =>
+ state.isFullscreen &&
+ find.byType(AppBar).evaluate().isEmpty &&
+ (Platform.isIOS ||
+ MediaQuery.orientationOf(
+ tester.element(find.byType(ExternalVideoViewer)),
+ ) ==
+ Orientation.landscape),
+ );
+ expect(find.byType(AppBar), findsNothing);
+ expect(state.controller, same(controller));
+ await tester.binding.handlePopRoute();
+ await _pumpUntil(
+ tester,
+ () =>
+ !state.isFullscreen &&
+ find.byType(AppBar).evaluate().isNotEmpty &&
+ (Platform.isIOS ||
+ MediaQuery.orientationOf(
+ tester.element(find.byType(ExternalVideoViewer)),
+ ) ==
+ Orientation.portrait),
+ );
+ expect(find.byType(AppBar), findsOneWidget);
+ expect(controller.playbackStatus, PlaybackStatus.playing);
+ expect(state.controller, same(controller));
+
+ final closed = Completer<void>();
+ final subscription = controller.events.listen(
+ (_) {},
+ onDone: closed.complete,
+ );
+ await tester.pumpWidget(const SizedBox.shrink());
+ await _pumpUntil(tester, () => closed.isCompleted);
+ await subscription.cancel();
+ expect(tester.takeException(), isNull);
+ });
+
+ testWidgets("plays an Android content URI without a filesystem path", (
+ tester,
+ ) async {
+ AssetEntity? asset;
+ await PhotoManager.setIgnorePermissionCheck(true);
+ try {
+ asset = await PhotoManager.editor.saveVideo(
+ videoFile,
+ title: "external_video_viewer_test.mp4",
+ relativePath: "Movies/EnteExternalVideoTest",
+ );
+ final uri = await asset.getMediaUrl();
+ expect(uri, startsWith("content://"));
+ final state = await _openVideo(tester, uri!);
+ expect(state.controller!.videoInfo!.width, 320);
+ expect(state.controller!.videoInfo!.height, 640);
+ expect(tester.takeException(), isNull);
+ } finally {
+ await tester.pumpWidget(const SizedBox.shrink());
+ if (asset != null) {
+ // Deleting our own file avoids Android's native confirmation dialog.
+ final createdFile = await asset.originFile;
+ if (createdFile != null && await createdFile.exists()) {
+ await createdFile.delete();
+ }
+ if (await asset.exists) {
+ await PhotoManager.editor.deleteWithIds([asset.id]);
+ }
+ }
+ await PhotoManager.setIgnorePermissionCheck(false);
+ }
+ }, skip: !Platform.isAndroid);
+
+ testWidgets("preserves the display aspect ratio of a rotated iOS video", (
+ tester,
+ ) async {
+ final bytes = base64Decode(_portraitVideo);
+ final trackHeader = String.fromCharCodes(bytes).indexOf("tkhd");
+ expect(trackHeader, greaterThan(0));
+ // A quarter-turn in the MP4 track matrix keeps encoded pixels unchanged.
+ final matrix = ByteData.sublistView(bytes, trackHeader + 44);
+ matrix.setInt32(0, 0);
+ matrix.setInt32(4, 65536);
+ matrix.setInt32(12, -65536);
+ matrix.setInt32(16, 0);
+ await videoFile.delete();
+ videoFile = File(
+ "${videoFile.parent.path}/external_video_viewer_rotated_test.mp4",
+ );
+ await videoFile.writeAsBytes(bytes);
+ await _openVideo(tester, videoFile.uri.toString());
+ final size = tester.getSize(find.byType(NativeVideoPlayerView));
+ expect(size.width / size.height, closeTo(2, 0.01));
+ await tester.pumpWidget(const SizedBox.shrink());
+ expect(tester.takeException(), isNull);
+ }, skip: !Platform.isIOS);
+
+ testWidgets("shows an error when an external video cannot be opened", (
+ tester,
+ ) async {
+ await tester.pumpWidget(
+ MaterialApp(home: _TestViewer(uri: "${videoFile.path}.missing")),
+ );
+ await _pumpUntil(
+ tester,
+ () => find.byIcon(Icons.error_outline).evaluate().isNotEmpty,
+ );
+ expect(find.byType(NativeVideoPlayerView), findsNothing);
+ await tester.pumpWidget(const SizedBox.shrink());
+ expect(tester.takeException(), isNull);
+ });
+}
+
+class _TestViewer extends StatefulWidget {
+ final String uri;
+
+ const _TestViewer({required this.uri});
+
+ @override
+ State<_TestViewer> createState() => _TestViewerState();
+}
+
+class _TestViewerState extends State<_TestViewer> {
+ final _videoKey = GlobalKey<ExternalVideoViewerState>();
+ bool _fullscreen = false;
+
+ @override
+ Widget build(BuildContext context) {
+ return PopScope(
+ canPop: !_fullscreen,
+ onPopInvokedWithResult: (didPop, _) {
+ if (!didPop && _fullscreen) {
+ unawaited(_videoKey.currentState!.exitFullscreen());
+ }
+ },
+ child: Scaffold(
+ appBar: _fullscreen ? null : AppBar(),
+ body: ExternalVideoViewer(
+ key: _videoKey,
+ uri: widget.uri,
+ onFullscreenChanged: (fullscreen) =>
+ setState(() => _fullscreen = fullscreen),
+ ),
+ ),
+ );
+ }
+}
+
+Future<ExternalVideoViewerState> _openVideo(
+ WidgetTester tester,
+ String uri,
+) async {
+ await tester.pumpWidget(
+ MaterialApp(
+ key: ValueKey(uri),
+ home: _TestViewer(uri: uri),
+ ),
+ );
+ final state = tester.state<ExternalVideoViewerState>(
+ find.byType(ExternalVideoViewer),
+ );
+ await _pumpUntil(
+ tester,
+ () =>
+ state.controller?.playbackStatus == PlaybackStatus.playing &&
+ state.controller?.videoInfo != null &&
+ state.controller!.playbackPosition > Duration.zero,
+ );
+ return state;
+}
+
+Future<void> _showControls(WidgetTester tester) async {
+ final opacity = tester.widget<AnimatedOpacity>(
+ find.descendant(
+ of: find.byType(ExternalVideoViewer),
+ matching: find.byType(AnimatedOpacity),
+ ),
+ );
+ if (opacity.opacity == 0) {
+ final bounds = tester.getRect(find.byType(ExternalVideoViewer));
+ await tester.tapAt(bounds.topLeft + const Offset(20, 20));
+ }
+ await tester.pump(const Duration(milliseconds: 250));
+}
+
+Future<void> _pumpUntil(WidgetTester tester, bool Function() condition) async {
+ final deadline = DateTime.now().add(const Duration(seconds: 20));
+ while (!condition() && DateTime.now().isBefore(deadline)) {
+ if (tester.binding.lifecycleState == AppLifecycleState.paused) {
+ // A paused iOS engine cannot deliver the frame tester.pump waits for.
+ await tester.runAsync(
+ () => Future<void>.delayed(const Duration(milliseconds: 100)),
+ );
+ } else {
+ await tester.pump(const Duration(milliseconds: 100));
+ }
+ }
+ expect(condition(), isTrue, reason: "Timed out waiting for video playback");
+}
+
+// Generated with FFmpeg: 4 seconds of green, 320x640, 30 fps, H.264 baseline/yuv420p.
+const _portraitVideo =
+ "AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAUEbW9vdgAAAGxtdmhkAAAAAAAA"
+ "AAAAAAAAAAAD6AAAD6AAAQAAAQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAA"
+ "AAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAABC90cmFrAAAAXHRr"
+ "aGQAAAADAAAAAAAAAAAAAAABAAAAAAAAD6AAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAA"
+ "AAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAUAAAAKAAAAAAAAkZWR0cwAAABxlbHN0AAAAAAAA"
+ "AAEAAA+gAAAAAAABAAAAAAOnbWRpYQAAACBtZGhkAAAAAAAAAAAAAAAAAAA8AAAA8ABVxAAA"
+ "AAAALWhkbHIAAAAAAAAAAHZpZGUAAAAAAAAAAAAAAABWaWRlb0hhbmRsZXIAAAADUm1pbmYA"
+ "AAAUdm1oZAAAAAEAAAAAAAAAAAAAACRkaW5mAAAAHGRyZWYAAAAAAAAAAQAAAAx1cmwgAAAA"
+ "AQAAAxJzdGJsAAAAunN0c2QAAAAAAAAAAQAAAKphdmMxAAAAAAAAAAEAAAAAAAAAAAAAAAAA"
+ "AAAAAUACgABIAAAASAAAAAAAAAABFExhdmM2MC4zLjEwMCBsaWJ4MjY0AAAAAAAAAAAAAAAA"
+ "GP//AAAAMGF2Y0MBQsAe/+EAGGdCwB7ZAUBRsBEAAAMAAQAAAwA8DxYuSAEABWjLg8sgAAAA"
+ "EHBhc3AAAAABAAAAAQAAABRidHJ0AAAAAAAAFA4AABQOAAAAGHN0dHMAAAAAAAAAAQAAAHgA"
+ "AAIAAAAAFHN0c3MAAAAAAAAAAQAAAAEAAAAcc3RzYwAAAAAAAAABAAAAAQAAAHgAAAABAAAB"
+ "9HN0c3oAAAAAAAAAAAAAAHgAAATpAAAACwAAAAwAAAALAAAACwAAAAsAAAALAAAACwAAAAsA"
+ "AAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAA"
+ "CwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsA"
+ "AAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAA"
+ "CwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsA"
+ "AAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAA"
+ "CwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsA"
+ "AAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAA"
+ "CwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsA"
+ "AAALAAAACwAAAAsAAAAUc3RjbwAAAAAAAAABAAAFNAAAAGF1ZHRhAAAAWW1ldGEAAAAAAAAA"
+ "IWhkbHIAAAAAAAAAAG1kaXJhcHBsAAAAAAAAAAAAAAAALGlsc3QAAAAkqXRvbwAAABxkYXRh"
+ "AAAAAQAAAABMYXZmNjAuMy4xMDAAAAAIZnJlZQAACg9tZGF0AAACcgYF//9u3EXpvebZSLeW"
+ "LNgg2SPu73gyNjQgLSBjb3JlIDE2NCByMzA3NSA2NmE1YmMxIC0gSC4yNjQvTVBFRy00IEFW"
+ "QyBjb2RlYyAtIENvcHlsZWZ0IDIwMDMtMjAyMSAtIGh0dHA6Ly93d3cudmlkZW9sYW4ub3Jn"
+ "L3gyNjQuaHRtbCAtIG9wdGlvbnM6IGNhYmFjPTAgcmVmPTMgZGVibG9jaz0xOjA6MCBhbmFs"
+ "eXNlPTB4MToweDExMSBtZT1oZXggc3VibWU9NyBwc3k9MSBwc3lfcmQ9MS4wMDowLjAwIG1p"
+ "eGVkX3JlZj0xIG1lX3JhbmdlPTE2IGNocm9tYV9tZT0xIHRyZWxsaXM9MSA4eDhkY3Q9MCBj"
+ "cW09MCBkZWFkem9uZT0yMSwxMSBmYXN0X3Bza2lwPTEgY2hyb21hX3FwX29mZnNldD0tMiB0"
+ "aHJlYWRzPTE4IGxvb2thaGVhZF90aHJlYWRzPTMgc2xpY2VkX3RocmVhZHM9MCBucj0wIGRl"
+ "Y2ltYXRlPTEgaW50ZXJsYWNlZD0wIGJsdXJheV9jb21wYXQ9MCBjb25zdHJhaW5lZF9pbnRy"
+ "YT0wIGJmcmFtZXM9MCB3ZWlnaHRwPTAga2V5aW50PTI1MCBrZXlpbnRfbWluPTI1IHNjZW5l"
+ "Y3V0PTQwIGludHJhX3JlZnJlc2g9MCByY19sb29rYWhlYWQ9NDAgcmM9Y3JmIG1idHJlZT0x"
+ "IGNyZj0yMy4wIHFjb21wPTAuNjAgcXBtaW49MCBxcG1heD02OSBxcHN0ZXA9NCBpcF9yYXRp"
+ "bz0xLjQwIGFxPTE6MS4wMACAAAACb2WIhAvxGKAAJHMcAARBY4AAiqycnJycnJycnJycnJyc"
+ "nJycnJyddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+ "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddeAAAA"
+ "B0GaOBfgDIYAAAAIQZpUBfgDIYAAAAAHQZpgL8AZDAAAAAdBmoAvwBkMAAAAB0GaoC/AGQwA"
+ "AAAHQZrAL8AZDAAAAAdBmuAvwBkMAAAAB0GbAC/AGQwAAAAHQZsgL8AZDAAAAAdBm0AvwBkM"
+ "AAAAB0GbYC/AGQwAAAAHQZuAL8AZDAAAAAdBm6AvwBkMAAAAB0GbwC/AGQwAAAAHQZvgL8AZ"
+ "DAAAAAdBmgAvwBkMAAAAB0GaIC/AGQwAAAAHQZpAL8AZDAAAAAdBmmAvwBkMAAAAB0GagC/A"
+ "GQwAAAAHQZqgL8AZDAAAAAdBmsAvwBkMAAAAB0Ga4C/AGQwAAAAHQZsAL8AZDAAAAAdBmyAv"
+ "wBkMAAAAB0GbQC/AGQwAAAAHQZtgL8AZDAAAAAdBm4AvwBkMAAAAB0GboC/AGQwAAAAHQZvA"
+ "L8AZDAAAAAdBm+AvwBkMAAAAB0GaAC/AGQwAAAAHQZogL8AZDAAAAAdBmkAvwBkMAAAAB0Ga"
+ "YC/AGQwAAAAHQZqAL8AZDAAAAAdBmqAvwBkMAAAAB0GawC/AGQwAAAAHQZrgL8AZDAAAAAdB"
+ "mwAvwBkMAAAAB0GbIC/AGQwAAAAHQZtAL8AZDAAAAAdBm2AvwBkMAAAAB0GbgC/AGQwAAAAH"
+ "QZugL8AZDAAAAAdBm8AvwBkMAAAAB0Gb4C/AGQwAAAAHQZoAL8AZDAAAAAdBmiAvwBkMAAAA"
+ "B0GaQC/AGQwAAAAHQZpgL8AZDAAAAAdBmoAvwBkMAAAAB0GaoC/AGQwAAAAHQZrAL8AZDAAA"
+ "AAdBmuAvwBkMAAAAB0GbAC/AGQwAAAAHQZsgL8AZDAAAAAdBm0AvwBkMAAAAB0GbYC/AGQwA"
+ "AAAHQZuAL8AZDAAAAAdBm6AvwBkMAAAAB0GbwC/AGQwAAAAHQZvgL8AZDAAAAAdBmgAvwBkM"
+ "AAAAB0GaIC/AGQwAAAAHQZpAL8AZDAAAAAdBmmAvwBkMAAAAB0GagC/AGQwAAAAHQZqgL8AZ"
+ "DAAAAAdBmsAvwBkMAAAAB0Ga4C/AGQwAAAAHQZsAL8AZDAAAAAdBmyAvwBkMAAAAB0GbQC/A"
+ "GQwAAAAHQZtgL8AZDAAAAAdBm4AvwBkMAAAAB0GboC/AGQwAAAAHQZvAL8AZDAAAAAdBm+Av"
+ "wBkMAAAAB0GaAC/AGQwAAAAHQZogL8AZDAAAAAdBmkAvwBkMAAAAB0GaYC/AGQwAAAAHQZqA"
+ "L8AZDAAAAAdBmqAvwBkMAAAAB0GawC/AGQwAAAAHQZrgL8AZDAAAAAdBmwAvwBkMAAAAB0Gb"
+ "IC/AGQwAAAAHQZtAL8AZDAAAAAdBm2AvwBkMAAAAB0GbgC/AGQwAAAAHQZugL8AZDAAAAAdB"
+ "m8AvwBkMAAAAB0Gb4C/AGQwAAAAHQZoAL8AZDAAAAAdBmiAvwBkMAAAAB0GaQC/AGQwAAAAH"
+ "QZpgL8AZDAAAAAdBmoAvwBkMAAAAB0GaoC/AGQwAAAAHQZrAL8AZDAAAAAdBmuAvwBkMAAAA"
+ "B0GbAC/AGQwAAAAHQZsgL8AZDAAAAAdBm0AvwBkMAAAAB0GbYC/AGQwAAAAHQZuAL8AZDAAA"
+ "AAdBm6AvwBkMAAAAB0GbwC/AGQwAAAAHQZvgL8AZDAAAAAdBmgAvwBkMAAAAB0GaIC/AGQwA"
+ "AAAHQZpAL8AZDAAAAAdBmmAvwBkMAAAAB0GagC/AGQwAAAAHQZqgL8AZDAAAAAdBmsArwBkM"
+ "AAAAB0Ga4CfAGQw=";
diff --git a/mobile/apps/photos/lib/ui/viewer/actions/file_viewer.dart b/mobile/apps/photos/lib/ui/viewer/actions/file_viewer.dart
index 0a3046ca8c..c567a66bee 100644
--- a/mobile/apps/photos/lib/ui/viewer/actions/file_viewer.dart
+++ b/mobile/apps/photos/lib/ui/viewer/actions/file_viewer.dart
@@ -3,7 +3,6 @@ import 'dart:convert';
import "dart:io";
import "dart:math" as math;
-import "package:chewie/chewie.dart";
import "package:flutter/material.dart";
import "package:flutter/services.dart";
import "package:logging/logging.dart";
@@ -15,12 +14,11 @@ import "package:photos/models/file/file.dart";
import "package:photos/models/gallery_type.dart";
import "package:photos/models/metadata/file_magic.dart";
import "package:photos/module/metadata/local_file.dart";
-import "package:photos/module/metadata/video.dart";
import "package:photos/services/app_lifecycle_service.dart";
import "package:photos/ui/viewer/file/detail_page.dart";
+import "package:photos/ui/viewer/file/external_video_viewer.dart";
import "package:photos/ui/viewer/file/image_zoom/image_zoom_viewer.dart";
import "package:receive_sharing_intent/receive_sharing_intent.dart";
-import "package:video_player/video_player.dart";
class FileViewer extends StatefulWidget {
final SharedMediaFile? sharedMediaFile;
@@ -43,14 +41,12 @@ class FileViewerState extends State<FileViewer> {
];
final action = AppLifecycleService.instance.mediaExtensionAction;
- ChewieController? controller;
- VideoPlayerController? videoController;
final Logger _logger = Logger("FileViewer");
- double? aspectRatio;
Future<AssetEntity?>? mediaStoreAssetFuture;
Future<DetailPageConfiguration?>? reviewGalleryConfigFuture;
Future<Uint8List?>? grantedImageBytesFuture;
- bool _isInitializingVideoController = false;
+ final _externalVideoKey = GlobalKey<ExternalVideoViewerState>();
+ bool _isVideoFullscreen = false;
bool _isClosingViewer = false;
bool get _isExternalView =>
widget.sharedMediaFile == null &&
@@ -72,106 +68,11 @@ class FileViewerState extends State<FileViewer> {
mediaStoreAssetFuture = _loadMediaStoreAsset(action.data);
reviewGalleryConfigFuture = _loadReviewGalleryConfig();
}
- if (action.type == MediaType.video ||
- widget.sharedMediaFile?.type == SharedMediaType.video) {
- if (!_isExternalView) {
- _initializeVideoController();
- }
- } else if (action.type == MediaType.image &&
- mediaStoreAssetFuture == null) {
+ if (action.type == MediaType.image && mediaStoreAssetFuture == null) {
mediaStoreAssetFuture = _loadMediaStoreAsset(action.data);
}
}
- Future<void> _initializeVideoController() async {
- if (_isInitializingVideoController || controller != null) {
- return;
- }
- _isInitializingVideoController = true;
- try {
- await _fetchAspectRatio();
- if (!mounted) {
- return;
- }
- initController();
- } finally {
- _isInitializingVideoController = false;
- }
- }
-
- Future<void> _fetchAspectRatio() async {
- try {
- final videoPath = widget.sharedMediaFile?.path ?? action.data;
- if (videoPath == null) {
- _logger.warning("Video path is null, using default aspect ratio");
- aspectRatio = 16 / 9;
- return;
- }
-
- final videoFile = File(videoPath);
- if (!await videoFile.exists()) {
- _logger.warning(
- "Video file does not exist, using default aspect ratio",
- );
- aspectRatio = 16 / 9;
- return;
- }
-
- final videoProps = await getVideoProps(videoFile);
- if (videoProps != null &&
- videoProps.width != null &&
- videoProps.height != null &&
- videoProps.height != 0) {
- aspectRatio = videoProps.width! / videoProps.height!;
- _logger.info("Fetched video aspect ratio: $aspectRatio");
- } else {
- _logger.warning(
- "Could not get video dimensions, using default aspect ratio",
- );
- aspectRatio = 16 / 9;
- }
- } catch (e) {
- _logger.severe("Error fetching video aspect ratio: $e");
- aspectRatio = 16 / 9;
- }
- }
-
- @override
- void dispose() {
- videoController?.dispose();
- controller?.dispose();
- super.dispose();
- }
-
- void initController() async {
- videoController = VideoPlayerController.contentUri(
- widget.sharedMediaFile?.path != null
- ? Uri.parse(widget.sharedMediaFile!.path)
- : Uri.parse(action.data!),
- );
- controller = ChewieController(
- videoPlayerController: videoController!,
- autoInitialize: true,
- aspectRatio: aspectRatio ?? 16 / 9,
- autoPlay: true,
- looping: true,
- showOptions: false,
- materialProgressColors: ChewieProgressColors(
- playedColor: const Color.fromRGBO(45, 194, 98, 1.0),
- handleColor: Colors.white,
- bufferedColor: Colors.white,
- ),
- );
- controller!.addListener(() {
- if (!controller!.isFullScreen) {
- SystemChrome.setPreferredOrientations([DeviceOrientation.portraitUp]);
- }
- });
- if (mounted) {
- setState(() {});
- }
- }
-
Future<AssetEntity?>? _loadMediaStoreAsset(String? data) {
final uri = data == null ? null : Uri.tryParse(data);
final id = uri == null ? null : _mediaStoreAssetId(uri);
@@ -510,21 +411,30 @@ class FileViewerState extends State<FileViewer> {
}
Widget _buildVideoViewer() {
- if (controller != null) {
- return Chewie(controller: controller!);
+ final uri = widget.sharedMediaFile?.path ?? action.data;
+ if (uri == null || uri.isEmpty) {
+ _logger.severe("Video URI is missing");
+ return const Icon(Icons.error);
}
- unawaited(_initializeVideoController());
- return const CircularProgressIndicator();
+ return ExternalVideoViewer(
+ uri: uri,
+ key: _externalVideoKey,
+ onFullscreenChanged: (fullscreen) {
+ setState(() => _isVideoFullscreen = fullscreen);
+ },
+ );
}
Widget _buildSingleFileScaffold() {
return Scaffold(
- appBar: AppBar(
- leading: IconButton(
- onPressed: _closeViewer,
- icon: const Icon(Icons.arrow_back),
- ),
- ),
+ appBar: _isVideoFullscreen
+ ? null
+ : AppBar(
+ leading: IconButton(
+ onPressed: _closeViewer,
+ icon: const Icon(Icons.arrow_back),
+ ),
+ ),
body: Column(
children: [
Expanded(
@@ -579,13 +489,15 @@ class FileViewerState extends State<FileViewer> {
final scaffold = _isExternalView
? _buildReviewGalleryOrFallback()
: _buildSingleFileScaffold();
- if (!_isExternalView) {
- return scaffold;
- }
return PopScope(
- canPop: false,
+ canPop: !_isExternalView && !_isVideoFullscreen,
onPopInvokedWithResult: (didPop, result) {
- unawaited(_closeViewer());
+ if (didPop) return;
+ if (_isVideoFullscreen) {
+ unawaited(_externalVideoKey.currentState?.exitFullscreen());
+ } else if (_isExternalView) {
+ unawaited(_closeViewer());
+ }
},
child: scaffold,
);
diff --git a/mobile/apps/photos/lib/ui/viewer/file/external_video_viewer.dart b/mobile/apps/photos/lib/ui/viewer/file/external_video_viewer.dart
new file mode 100644
index 0000000000..04bf49ed50
--- /dev/null
+++ b/mobile/apps/photos/lib/ui/viewer/file/external_video_viewer.dart
@@ -0,0 +1,408 @@
+import "dart:async";
+import "dart:io";
+
+import "package:flutter/material.dart";
+import "package:flutter/services.dart";
+import "package:logging/logging.dart";
+import "package:native_video_player/native_video_player.dart";
+import "package:photos/ui/viewer/file/native_video_player_controls/play_pause_button.dart";
+import "package:photos/ui/viewer/file/video_seek_controller.dart";
+import "package:video_player/video_player.dart" as vp;
+import "package:wakelock_plus/wakelock_plus.dart";
+
+class ExternalVideoViewer extends StatefulWidget {
+ final String uri;
+ final ValueChanged<bool> onFullscreenChanged;
+
+ const ExternalVideoViewer({
+ required this.uri,
+ required this.onFullscreenChanged,
+ super.key,
+ });
+
+ @override
+ ExternalVideoViewerState createState() => ExternalVideoViewerState();
+}
+
+class ExternalVideoViewerState extends State<ExternalVideoViewer>
+ with WidgetsBindingObserver {
+ final _logger = Logger("ExternalVideoViewer");
+ NativeVideoPlayerController? _controller;
+ StreamSubscription<PlaybackEvent>? _subscription;
+ late final VideoSeekController _seekController;
+ Timer? _hideControlsTimer;
+ bool _hasError = false;
+ bool _isPlaybackReady = false;
+ bool _preparingPlayback = false;
+ bool _isFullscreen = false;
+ bool _isForeground = true;
+ bool _resumePlayback = false;
+ bool _showControls = true;
+ bool _isSeeking = false;
+ double? _displayAspectRatio;
+
+ NativeVideoPlayerController? get controller => _controller;
+ bool get isFullscreen => _isFullscreen;
+
+ Duration? get _duration {
+ final milliseconds = _controller?.videoInfo?.durationInMilliseconds;
+ return milliseconds == null ? null : Duration(milliseconds: milliseconds);
+ }
+
+ @override
+ void initState() {
+ super.initState();
+ WidgetsBinding.instance.addObserver(this);
+ final lifecycle = WidgetsBinding.instance.lifecycleState;
+ _isForeground = lifecycle == null || lifecycle == AppLifecycleState.resumed;
+ _seekController = VideoSeekController(
+ seek: (position) async => _controller?.seekTo(position),
+ readPosition: () => _controller?.playbackPosition ?? Duration.zero,
+ readDuration: () => _duration,
+ onSeekError: (error, stackTrace) {
+ _logger.warning("Could not seek external video", error, stackTrace);
+ },
+ )..addListener(_onSeekChanged);
+ }
+
+ Future<void> _initializeController(
+ NativeVideoPlayerController controller,
+ ) async {
+ if (!mounted) {
+ controller.dispose();
+ return;
+ }
+ _controller = controller;
+ _subscription = controller.events.listen(_onPlaybackEvent);
+ await _run(() async {
+ final uri = Uri.tryParse(widget.uri);
+ final path = uri?.scheme == "file" ? uri!.toFilePath() : widget.uri;
+ if (Platform.isIOS) await _probeIosAspectRatio(path);
+ if (!mounted || _hasError) return;
+ await controller.loadVideo(
+ VideoSource(path: path, type: VideoSourceType.file),
+ );
+ });
+ }
+
+ Future<void> _probeIosAspectRatio(String path) async {
+ // Native videoInfo omits rotation. A platform view probe also avoids
+ // texture composition failures when reading rotated iOS videos.
+ final metadataController = vp.VideoPlayerController.file(
+ File(path),
+ viewType: vp.VideoViewType.platformView,
+ );
+ try {
+ await metadataController.initialize().timeout(const Duration(seconds: 4));
+ final aspectRatio = metadataController.value.aspectRatio;
+ if (mounted && aspectRatio > 0) _displayAspectRatio = aspectRatio;
+ } catch (error, stackTrace) {
+ _logger.warning(
+ "Could not read external video dimensions",
+ error,
+ stackTrace,
+ );
+ } finally {
+ try {
+ await metadataController.dispose().timeout(const Duration(seconds: 4));
+ } catch (error, stackTrace) {
+ _logger.warning(
+ "Could not dispose video metadata probe",
+ error,
+ stackTrace,
+ );
+ }
+ }
+ }
+
+ void _onPlaybackEvent(PlaybackEvent event) {
+ if (!mounted) return;
+ switch (event) {
+ case PlaybackReadyEvent():
+ unawaited(_onPlaybackReady());
+ case PlaybackEndedEvent():
+ unawaited(_loopVideo());
+ case PlaybackErrorEvent():
+ _onPlaybackError(event.errorMessage);
+ case PlaybackPositionChangedEvent():
+ _seekController.onPlayerPosition(
+ _controller!.playbackPosition,
+ duration: _duration,
+ );
+ case PlaybackStatusChangedEvent():
+ if (event.status != PlaybackStatus.playing) {
+ setState(() => _showControls = true);
+ }
+ unawaited(
+ WakelockPlus.toggle(
+ enable: _isForeground && event.status == PlaybackStatus.playing,
+ ),
+ );
+ _scheduleHideControls();
+ case VolumeChangedEvent():
+ setState(() {});
+ default:
+ }
+ }
+
+ Future<void> _onPlaybackReady() async {
+ if (_isPlaybackReady || _preparingPlayback) return;
+ _preparingPlayback = true;
+ await _run(() async {
+ final controller = _controller!;
+ await controller.setVolume(controller.volume);
+ if (!mounted || _hasError) return;
+ _seekController.updateDuration(_duration);
+ setState(() => _isPlaybackReady = true);
+ if (_isForeground) {
+ await controller.play();
+ } else {
+ _resumePlayback = true;
+ }
+ });
+ }
+
+ Future<void> _loopVideo() async {
+ if (!_isForeground ||
+ _controller?.playbackStatus != PlaybackStatus.playing) {
+ return;
+ }
+ await _run(() async {
+ final controller = _controller!;
+ _seekController.reset(duration: _duration);
+ await controller.seekTo(Duration.zero);
+ if (mounted &&
+ _isForeground &&
+ controller.playbackStatus == PlaybackStatus.playing) {
+ await controller.play();
+ }
+ });
+ }
+
+ Future<void> _run(Future<void> Function() command) async {
+ if (!mounted || _hasError) return;
+ try {
+ await command();
+ } catch (error, stackTrace) {
+ if (mounted) _onPlaybackError(error, stackTrace);
+ }
+ }
+
+ void _onPlaybackError(Object error, [StackTrace? stackTrace]) {
+ _logger.warning("Could not play external video", error, stackTrace);
+ if (!mounted || _hasError) return;
+ _hideControlsTimer?.cancel();
+ unawaited(_subscription?.cancel());
+ _controller?.dispose();
+ _controller = null;
+ unawaited(WakelockPlus.disable());
+ if (_isFullscreen) unawaited(exitFullscreen());
+ setState(() => _hasError = true);
+ }
+
+ @override
+ void didChangeAppLifecycleState(AppLifecycleState state) {
+ if (state == AppLifecycleState.paused ||
+ state == AppLifecycleState.detached) {
+ if (!_isForeground) return;
+ _resumePlayback =
+ !_isPlaybackReady ||
+ _controller?.playbackStatus == PlaybackStatus.playing;
+ _isForeground = false;
+ unawaited(_run(() async => _controller?.pause()));
+ unawaited(WakelockPlus.disable());
+ } else if (state == AppLifecycleState.resumed) {
+ _isForeground = true;
+ if (_resumePlayback && _isPlaybackReady) {
+ _resumePlayback = false;
+ unawaited(_run(() async => _controller?.play()));
+ }
+ }
+ }
+
+ void _onSeekChanged() {
+ if (!mounted) return;
+ final isSeeking = _seekController.state.isInteracting;
+ if (_isSeeking != isSeeking) {
+ _isSeeking = isSeeking;
+ if (isSeeking) _showControls = true;
+ _scheduleHideControls();
+ }
+ setState(() {});
+ }
+
+ void _scheduleHideControls() {
+ _hideControlsTimer?.cancel();
+ if (_controller?.playbackStatus == PlaybackStatus.playing && !_isSeeking) {
+ _hideControlsTimer = Timer(const Duration(seconds: 2), () {
+ if (mounted) setState(() => _showControls = false);
+ });
+ }
+ }
+
+ Future<void> _setFullscreen(bool fullscreen) async {
+ if (!mounted || _isFullscreen == fullscreen) return;
+ setState(() => _isFullscreen = fullscreen);
+ widget.onFullscreenChanged(fullscreen);
+ await SystemChrome.setEnabledSystemUIMode(
+ fullscreen ? SystemUiMode.immersiveSticky : SystemUiMode.edgeToEdge,
+ );
+ await SystemChrome.setPreferredOrientations(
+ fullscreen
+ ? [DeviceOrientation.landscapeLeft, DeviceOrientation.landscapeRight]
+ : [DeviceOrientation.portraitUp],
+ );
+ }
+
+ Future<void> exitFullscreen() => _setFullscreen(false);
+
+ @override
+ void dispose() {
+ WidgetsBinding.instance.removeObserver(this);
+ _hideControlsTimer?.cancel();
+ unawaited(_subscription?.cancel());
+ _controller?.dispose();
+ _seekController.dispose();
+ unawaited(WakelockPlus.disable());
+ if (_isFullscreen) {
+ unawaited(SystemChrome.setEnabledSystemUIMode(SystemUiMode.edgeToEdge));
+ unawaited(
+ SystemChrome.setPreferredOrientations([DeviceOrientation.portraitUp]),
+ );
+ }
+ super.dispose();
+ }
+
+ @override
+ Widget build(BuildContext context) {
+ if (_hasError) {
+ return const ColoredBox(
+ color: Colors.black,
+ child: Center(child: Icon(Icons.error_outline, color: Colors.white)),
+ );
+ }
+ final info = _controller?.videoInfo;
+ final aspectRatio =
+ _displayAspectRatio ??
+ (info != null && info.width > 0 && info.height > 0
+ ? info.width / info.height
+ : 16 / 9);
+ return ColoredBox(
+ color: Colors.black,
+ child: Stack(
+ fit: StackFit.expand,
+ children: [
+ Center(
+ child: AspectRatio(
+ aspectRatio: aspectRatio,
+ child: NativeVideoPlayerView(onViewReady: _initializeController),
+ ),
+ ),
+ if (!_isPlaybackReady)
+ const Center(child: CircularProgressIndicator(color: Colors.white)),
+ if (_isPlaybackReady) _buildControls(),
+ ],
+ ),
+ );
+ }
+
+ Widget _buildControls() {
+ final duration = _seekController.duration ?? Duration.zero;
+ final position = _seekController.position;
+ final isMuted = _controller!.volume == 0;
+ return GestureDetector(
+ behavior: HitTestBehavior.opaque,
+ onTap: () {
+ setState(() => _showControls = !_showControls);
+ _scheduleHideControls();
+ },
+ child: AnimatedOpacity(
+ opacity: _showControls ? 1 : 0,
+ duration: const Duration(milliseconds: 200),
+ child: IgnorePointer(
+ ignoring: !_showControls,
+ child: Stack(
+ children: [
+ Center(child: PlayPauseButton(_controller)),
+ Positioned(
+ left: 0,
+ right: 0,
+ bottom: 0,
+ child: SafeArea(
+ top: false,
+ child: ColoredBox(
+ color: Colors.black54,
+ child: Row(
+ children: [
+ Expanded(
+ child: Slider(
+ value: duration > Duration.zero
+ ? (position.inMilliseconds /
+ duration.inMilliseconds)
+ .clamp(0.0, 1.0)
+ : 0,
+ activeColor: Colors.white,
+ inactiveColor: Colors.white30,
+ onChangeStart: _seekController.canSeek
+ ? (_) =>
+ _seekController.beginSliderInteraction()
+ : null,
+ onChanged: _seekController.canSeek
+ ? (value) => _seekController.updateSliderTarget(
+ _positionAt(value),
+ )
+ : null,
+ onChangeEnd: _seekController.canSeek
+ ? (value) => _seekController
+ .endSliderInteraction(_positionAt(value))
+ : null,
+ ),
+ ),
+ Text(
+ "${_formatTime(position)} / ${_formatTime(duration)}",
+ style: const TextStyle(
+ color: Colors.white,
+ fontSize: 12,
+ ),
+ ),
+ IconButton(
+ color: Colors.white,
+ onPressed: () => unawaited(
+ _run(() => _controller!.setVolume(isMuted ? 1 : 0)),
+ ),
+ icon: Icon(
+ isMuted ? Icons.volume_off : Icons.volume_up,
+ ),
+ ),
+ IconButton(
+ color: Colors.white,
+ onPressed: () =>
+ unawaited(_setFullscreen(!_isFullscreen)),
+ icon: Icon(
+ _isFullscreen
+ ? Icons.fullscreen_exit
+ : Icons.fullscreen,
+ ),
+ ),
+ ],
+ ),
+ ),
+ ),
+ ),
+ ],
+ ),
+ ),
+ ),
+ );
+ }
+
+ Duration _positionAt(double value) {
+ final duration = _seekController.duration ?? Duration.zero;
+ return Duration(milliseconds: (duration.inMilliseconds * value).round());
+ }
+
+ String _formatTime(Duration value) {
+ final seconds = (value.inSeconds % 60).toString().padLeft(2, "0");
+ return "${value.inMinutes}:$seconds";
+ }
+}
diff --git a/mobile/apps/photos/lib/ui/viewer/file/file_widget.dart b/mobile/apps/photos/lib/ui/viewer/file/file_widget.dart
index a03cf4462c..e7314e6026 100644
--- a/mobile/apps/photos/lib/ui/viewer/file/file_widget.dart
+++ b/mobile/apps/photos/lib/ui/viewer/file/file_widget.dart
@@ -75,16 +75,6 @@ class FileWidget extends StatelessWidget {
onTextSelectionStart: onTextSelectionStart,
);
} else if (file.fileType == FileType.video) {
- // use old video widget on iOS simulator as the new one crashes while
- // playing certain videos on iOS simulator
- // if (kDebugMode && Platform.isIOS) {
- // return VideoWidgetChewie(
- // file,
- // tagPrefix: tagPrefix,
- // playbackCallback: playbackCallback,
- // );
- // }
-
return VideoWidget(
file,
tagPrefix: tagPrefix,
diff --git a/mobile/apps/photos/lib/ui/viewer/file/video_control/custom_progress_bar.dart b/mobile/apps/photos/lib/ui/viewer/file/video_control/custom_progress_bar.dart
deleted file mode 100644
index 563f6d1a07..0000000000
--- a/mobile/apps/photos/lib/ui/viewer/file/video_control/custom_progress_bar.dart
+++ /dev/null
@@ -1,41 +0,0 @@
-// ignore_for_file: implementation_imports
-
-import "package:chewie/src/chewie_progress_colors.dart";
-import "package:chewie/src/progress_bar.dart";
-import "package:flutter/material.dart";
-import "package:flutter/widgets.dart";
-import "package:video_player/video_player.dart";
-
-class CustomProgressBar extends StatelessWidget {
- CustomProgressBar(
- this.controller, {
- ChewieProgressColors? colors,
- this.onDragEnd,
- this.onDragStart,
- this.onDragUpdate,
- super.key,
- this.draggableProgressBar = true,
- }) : colors = colors ?? ChewieProgressColors();
-
- final VideoPlayerController controller;
- final ChewieProgressColors colors;
- final Function()? onDragStart;
- final Function()? onDragEnd;
- final Function()? onDragUpdate;
- final bool draggableProgressBar;
-
- @override
- Widget build(BuildContext context) {
- return VideoProgressBar(
- controller,
- barHeight: 1.5,
- handleHeight: 8,
- drawShadow: true,
- colors: colors,
- onDragEnd: onDragEnd,
- onDragStart: onDragStart,
- onDragUpdate: onDragUpdate,
- draggableProgressBar: draggableProgressBar,
- );
- }
-}
diff --git a/mobile/apps/photos/pubspec.yaml b/mobile/apps/photos/pubspec.yaml
index 9c2cd8632b..fe701f2d9e 100644
--- a/mobile/apps/photos/pubspec.yaml
+++ b/mobile/apps/photos/pubspec.yaml
@@ -18,7 +18,6 @@ dependencies:
path: ../../packages/backup_exclusion
bip39: 1.0.6
camera: 0.12.1
- chewie: 1.13.0
collection: 1.19.1
computer: # logged task name in verbose in fork
git:
diff --git a/mobile/pubspec.lock b/mobile/pubspec.lock
index c10ce59f44..2fae43bc5d 100644
--- a/mobile/pubspec.lock
+++ b/mobile/pubspec.lock
@@ -297,14 +297,6 @@ packages:
url: "https://pub.dev"
source: hosted
version: "2.0.4"
- chewie:
- dependency: transitive
- description:
- name: chewie
- sha256: "44bcfc5f0dfd1de290c87c9d86a61308b3282a70b63435d5557cfd60f54a69ca"
- url: "https://pub.dev"
- source: hosted
- version: "1.13.0"
cli_config:
dependency: transitive
description: