blob: 973fab42bb02c840c28c7c21469dd3b16397c9f9 [file] [log] [blame]
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'dart:async';
import 'dart:io';
import 'dart:math' as math;
import 'dart:typed_data';
import 'package:flutter/material.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:video_player/video_player.dart';
import 'package:video_player_platform_interface/video_player_platform_interface.dart';
class FakeController extends ValueNotifier<VideoPlayerValue>
implements VideoPlayerController {
FakeController() : super(VideoPlayerValue(duration: Duration.zero));
FakeController.value(VideoPlayerValue value) : super(value);
@override
Future<void> dispose() async {
super.dispose();
}
@override
int textureId = VideoPlayerController.kUninitializedTextureId;
@override
String get dataSource => '';
@override
Map<String, String> get httpHeaders => <String, String>{};
@override
DataSourceType get dataSourceType => DataSourceType.file;
@override
String get package => '';
@override
Future<Duration> get position async => value.position;
@override
Future<void> seekTo(Duration moment) async {}
@override
Future<void> setVolume(double volume) async {}
@override
Future<void> setPlaybackSpeed(double speed) async {}
@override
Future<void> initialize() async {}
@override
Future<void> pause() async {}
@override
Future<void> play() async {}
@override
Future<void> setLooping(bool looping) async {}
@override
VideoFormat? get formatHint => null;
@override
Future<ClosedCaptionFile> get closedCaptionFile => _loadClosedCaption();
@override
VideoPlayerOptions? get videoPlayerOptions => null;
@override
void setCaptionOffset(Duration delay) {}
@override
Future<void> setClosedCaptionFile(
Future<ClosedCaptionFile>? closedCaptionFile,
) async {}
}
Future<ClosedCaptionFile> _loadClosedCaption() async =>
_FakeClosedCaptionFile();
class _FakeClosedCaptionFile extends ClosedCaptionFile {
@override
List<Caption> get captions {
return <Caption>[
const Caption(
text: 'one',
number: 0,
start: Duration(milliseconds: 100),
end: Duration(milliseconds: 200),
),
const Caption(
text: 'two',
number: 1,
start: Duration(milliseconds: 300),
end: Duration(milliseconds: 400),
),
];
}
}
void main() {
void verifyPlayStateRespondsToLifecycle(
VideoPlayerController controller, {
required bool shouldPlayInBackground,
}) {
expect(controller.value.isPlaying, true);
_ambiguate(WidgetsBinding.instance)!
.handleAppLifecycleStateChanged(AppLifecycleState.paused);
expect(controller.value.isPlaying, shouldPlayInBackground);
_ambiguate(WidgetsBinding.instance)!
.handleAppLifecycleStateChanged(AppLifecycleState.resumed);
expect(controller.value.isPlaying, true);
}
testWidgets('update texture', (WidgetTester tester) async {
final FakeController controller = FakeController();
await tester.pumpWidget(VideoPlayer(controller));
expect(find.byType(Texture), findsNothing);
controller.textureId = 123;
controller.value = controller.value.copyWith(
duration: const Duration(milliseconds: 100),
isInitialized: true,
);
await tester.pump();
expect(find.byType(Texture), findsOneWidget);
});
testWidgets('update controller', (WidgetTester tester) async {
final FakeController controller1 = FakeController();
controller1.textureId = 101;
await tester.pumpWidget(VideoPlayer(controller1));
expect(
find.byWidgetPredicate(
(Widget widget) => widget is Texture && widget.textureId == 101,
),
findsOneWidget);
final FakeController controller2 = FakeController();
controller2.textureId = 102;
await tester.pumpWidget(VideoPlayer(controller2));
expect(
find.byWidgetPredicate(
(Widget widget) => widget is Texture && widget.textureId == 102,
),
findsOneWidget);
});
testWidgets('non-zero rotationCorrection value is used',
(WidgetTester tester) async {
final FakeController controller = FakeController.value(
VideoPlayerValue(duration: Duration.zero, rotationCorrection: 180));
controller.textureId = 1;
await tester.pumpWidget(VideoPlayer(controller));
final Transform actualRotationCorrection =
find.byType(Transform).evaluate().single.widget as Transform;
final Float64List actualRotationCorrectionStorage =
actualRotationCorrection.transform.storage;
final Float64List expectedMatrixStorage =
Matrix4.rotationZ(math.pi).storage;
expect(actualRotationCorrectionStorage.length,
equals(expectedMatrixStorage.length));
for (int i = 0; i < actualRotationCorrectionStorage.length; i++) {
expect(actualRotationCorrectionStorage[i],
moreOrLessEquals(expectedMatrixStorage[i]));
}
});
testWidgets('no transform when rotationCorrection is zero',
(WidgetTester tester) async {
final FakeController controller =
FakeController.value(VideoPlayerValue(duration: Duration.zero));
controller.textureId = 1;
await tester.pumpWidget(VideoPlayer(controller));
expect(find.byType(Transform), findsNothing);
});
group('ClosedCaption widget', () {
testWidgets('uses a default text style', (WidgetTester tester) async {
const String text = 'foo';
await tester
.pumpWidget(const MaterialApp(home: ClosedCaption(text: text)));
final Text textWidget = tester.widget<Text>(find.text(text));
expect(textWidget.style!.fontSize, 36.0);
expect(textWidget.style!.color, Colors.white);
});
testWidgets('uses given text and style', (WidgetTester tester) async {
const String text = 'foo';
const TextStyle textStyle = TextStyle(fontSize: 14.725);
await tester.pumpWidget(const MaterialApp(
home: ClosedCaption(
text: text,
textStyle: textStyle,
),
));
expect(find.text(text), findsOneWidget);
final Text textWidget = tester.widget<Text>(find.text(text));
expect(textWidget.style!.fontSize, textStyle.fontSize);
});
testWidgets('handles null text', (WidgetTester tester) async {
await tester.pumpWidget(const MaterialApp(home: ClosedCaption()));
expect(find.byType(Text), findsNothing);
});
testWidgets('handles empty text', (WidgetTester tester) async {
await tester.pumpWidget(const MaterialApp(home: ClosedCaption(text: '')));
expect(find.byType(Text), findsNothing);
});
testWidgets('Passes text contrast ratio guidelines',
(WidgetTester tester) async {
const String text = 'foo';
await tester.pumpWidget(const MaterialApp(
home: Scaffold(
backgroundColor: Colors.white,
body: ClosedCaption(text: text),
),
));
expect(find.text(text), findsOneWidget);
await expectLater(tester, meetsGuideline(textContrastGuideline));
}, skip: isBrowser);
});
group('VideoPlayerController', () {
late FakeVideoPlayerPlatform fakeVideoPlayerPlatform;
setUp(() {
fakeVideoPlayerPlatform = FakeVideoPlayerPlatform();
VideoPlayerPlatform.instance = fakeVideoPlayerPlatform;
});
group('initialize', () {
test('started app lifecycle observing', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
await controller.play();
verifyPlayStateRespondsToLifecycle(controller,
shouldPlayInBackground: false);
});
test('asset', () async {
final VideoPlayerController controller = VideoPlayerController.asset(
'a.avi',
);
await controller.initialize();
expect(fakeVideoPlayerPlatform.dataSources[0].asset, 'a.avi');
expect(fakeVideoPlayerPlatform.dataSources[0].package, null);
});
test('network', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
expect(
fakeVideoPlayerPlatform.dataSources[0].uri,
'https://127.0.0.1',
);
expect(
fakeVideoPlayerPlatform.dataSources[0].formatHint,
null,
);
expect(
fakeVideoPlayerPlatform.dataSources[0].httpHeaders,
<String, String>{},
);
});
test('network with hint', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
formatHint: VideoFormat.dash,
);
await controller.initialize();
expect(
fakeVideoPlayerPlatform.dataSources[0].uri,
'https://127.0.0.1',
);
expect(
fakeVideoPlayerPlatform.dataSources[0].formatHint,
VideoFormat.dash,
);
expect(
fakeVideoPlayerPlatform.dataSources[0].httpHeaders,
<String, String>{},
);
});
test('network with some headers', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
httpHeaders: <String, String>{'Authorization': 'Bearer token'},
);
await controller.initialize();
expect(
fakeVideoPlayerPlatform.dataSources[0].uri,
'https://127.0.0.1',
);
expect(
fakeVideoPlayerPlatform.dataSources[0].formatHint,
null,
);
expect(
fakeVideoPlayerPlatform.dataSources[0].httpHeaders,
<String, String>{'Authorization': 'Bearer token'},
);
});
test('init errors', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'http://testing.com/invalid_url',
);
late Object error;
fakeVideoPlayerPlatform.forceInitError = true;
await controller.initialize().catchError((Object e) => error = e);
final PlatformException platformEx = error as PlatformException;
expect(platformEx.code, equals('VideoError'));
});
test('file', () async {
final VideoPlayerController controller =
VideoPlayerController.file(File('a.avi'));
await controller.initialize();
expect(fakeVideoPlayerPlatform.dataSources[0].uri, 'file://a.avi');
});
test('successful initialize on controller with error clears error',
() async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
fakeVideoPlayerPlatform.forceInitError = true;
await controller.initialize().catchError((dynamic e) {});
expect(controller.value.hasError, equals(true));
fakeVideoPlayerPlatform.forceInitError = false;
await controller.initialize();
expect(controller.value.hasError, equals(false));
});
});
test('contentUri', () async {
final VideoPlayerController controller =
VideoPlayerController.contentUri(Uri.parse('content://video'));
await controller.initialize();
expect(fakeVideoPlayerPlatform.dataSources[0].uri, 'content://video');
});
test('dispose', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
expect(
controller.textureId, VideoPlayerController.kUninitializedTextureId);
expect(await controller.position, Duration.zero);
await controller.initialize();
await controller.dispose();
expect(controller.textureId, 0);
expect(await controller.position, isNull);
});
test('calling dispose() on disposed controller does not throw', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
await controller.dispose();
expect(() async => controller.dispose(), returnsNormally);
});
test('play', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
expect(controller.value.isPlaying, isFalse);
await controller.play();
expect(controller.value.isPlaying, isTrue);
// The two last calls will be "play" and then "setPlaybackSpeed". The
// reason for this is that "play" calls "setPlaybackSpeed" internally.
expect(
fakeVideoPlayerPlatform
.calls[fakeVideoPlayerPlatform.calls.length - 2],
'play');
expect(fakeVideoPlayerPlatform.calls.last, 'setPlaybackSpeed');
});
test('play before initialized does not call platform', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
expect(controller.value.isInitialized, isFalse);
await controller.play();
expect(fakeVideoPlayerPlatform.calls, isEmpty);
});
test('play restarts from beginning if video is at end', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
const Duration nonzeroDuration = Duration(milliseconds: 100);
controller.value = controller.value.copyWith(duration: nonzeroDuration);
await controller.seekTo(nonzeroDuration);
expect(controller.value.isPlaying, isFalse);
expect(controller.value.position, nonzeroDuration);
await controller.play();
expect(controller.value.isPlaying, isTrue);
expect(controller.value.position, Duration.zero);
});
test('setLooping', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
expect(controller.value.isLooping, isFalse);
await controller.setLooping(true);
expect(controller.value.isLooping, isTrue);
});
test('pause', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
await controller.play();
expect(controller.value.isPlaying, isTrue);
await controller.pause();
expect(controller.value.isPlaying, isFalse);
expect(fakeVideoPlayerPlatform.calls.last, 'pause');
});
group('seekTo', () {
test('works', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
expect(await controller.position, Duration.zero);
await controller.seekTo(const Duration(milliseconds: 500));
expect(await controller.position, const Duration(milliseconds: 500));
});
test('before initialized does not call platform', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
expect(controller.value.isInitialized, isFalse);
await controller.seekTo(const Duration(milliseconds: 500));
expect(fakeVideoPlayerPlatform.calls, isEmpty);
});
test('clamps values that are too high or low', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
expect(await controller.position, Duration.zero);
await controller.seekTo(const Duration(seconds: 100));
expect(await controller.position, const Duration(seconds: 1));
await controller.seekTo(const Duration(seconds: -100));
expect(await controller.position, Duration.zero);
});
});
group('setVolume', () {
test('works', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
expect(controller.value.volume, 1.0);
const double volume = 0.5;
await controller.setVolume(volume);
expect(controller.value.volume, volume);
});
test('clamps values that are too high or low', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
expect(controller.value.volume, 1.0);
await controller.setVolume(-1);
expect(controller.value.volume, 0.0);
await controller.setVolume(11);
expect(controller.value.volume, 1.0);
});
});
group('setPlaybackSpeed', () {
test('works', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
expect(controller.value.playbackSpeed, 1.0);
const double speed = 1.5;
await controller.setPlaybackSpeed(speed);
expect(controller.value.playbackSpeed, speed);
});
test('rejects negative values', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
expect(controller.value.playbackSpeed, 1.0);
expect(() => controller.setPlaybackSpeed(-1), throwsArgumentError);
});
});
group('scrubbing', () {
testWidgets('restarts on release if already playing',
(WidgetTester tester) async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
final VideoProgressIndicator progressWidget =
VideoProgressIndicator(controller, allowScrubbing: true);
await tester.pumpWidget(Directionality(
textDirection: TextDirection.ltr,
child: progressWidget,
));
await controller.play();
expect(controller.value.isPlaying, isTrue);
final Rect progressRect = tester.getRect(find.byWidget(progressWidget));
await tester.dragFrom(progressRect.center, const Offset(1.0, 0.0));
await tester.pumpAndSettle();
expect(controller.value.position, lessThan(controller.value.duration));
expect(controller.value.isPlaying, isTrue);
await controller.pause();
});
testWidgets('does not restart when dragging to end',
(WidgetTester tester) async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
final VideoProgressIndicator progressWidget =
VideoProgressIndicator(controller, allowScrubbing: true);
await tester.pumpWidget(Directionality(
textDirection: TextDirection.ltr,
child: progressWidget,
));
await controller.play();
expect(controller.value.isPlaying, isTrue);
final Rect progressRect = tester.getRect(find.byWidget(progressWidget));
await tester.dragFrom(progressRect.center, progressRect.centerRight);
await tester.pumpAndSettle();
expect(controller.value.position, controller.value.duration);
expect(controller.value.isPlaying, isFalse);
});
});
group('caption', () {
test('works when seeking', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
closedCaptionFile: _loadClosedCaption(),
);
await controller.initialize();
expect(controller.value.position, Duration.zero);
expect(controller.value.caption.text, '');
await controller.seekTo(const Duration(milliseconds: 100));
expect(controller.value.caption.text, 'one');
await controller.seekTo(const Duration(milliseconds: 250));
expect(controller.value.caption.text, '');
await controller.seekTo(const Duration(milliseconds: 300));
expect(controller.value.caption.text, 'two');
await controller.seekTo(const Duration(milliseconds: 301));
expect(controller.value.caption.text, 'two');
await controller.seekTo(const Duration(milliseconds: 500));
expect(controller.value.caption.text, '');
await controller.seekTo(const Duration(milliseconds: 300));
expect(controller.value.caption.text, 'two');
await controller.seekTo(const Duration(milliseconds: 301));
expect(controller.value.caption.text, 'two');
});
test('works when seeking with captionOffset positive', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
closedCaptionFile: _loadClosedCaption(),
);
await controller.initialize();
controller.setCaptionOffset(const Duration(milliseconds: 100));
expect(controller.value.position, Duration.zero);
expect(controller.value.caption.text, '');
await controller.seekTo(const Duration(milliseconds: 100));
expect(controller.value.caption.text, 'one');
await controller.seekTo(const Duration(milliseconds: 101));
expect(controller.value.caption.text, '');
await controller.seekTo(const Duration(milliseconds: 250));
expect(controller.value.caption.text, 'two');
await controller.seekTo(const Duration(milliseconds: 300));
expect(controller.value.caption.text, 'two');
await controller.seekTo(const Duration(milliseconds: 301));
expect(controller.value.caption.text, '');
await controller.seekTo(const Duration(milliseconds: 500));
expect(controller.value.caption.text, '');
await controller.seekTo(const Duration(milliseconds: 300));
expect(controller.value.caption.text, 'two');
await controller.seekTo(const Duration(milliseconds: 301));
expect(controller.value.caption.text, '');
});
test('works when seeking with captionOffset negative', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
closedCaptionFile: _loadClosedCaption(),
);
await controller.initialize();
controller.setCaptionOffset(const Duration(milliseconds: -100));
expect(controller.value.position, Duration.zero);
expect(controller.value.caption.text, '');
await controller.seekTo(const Duration(milliseconds: 100));
expect(controller.value.caption.text, '');
await controller.seekTo(const Duration(milliseconds: 200));
expect(controller.value.caption.text, 'one');
await controller.seekTo(const Duration(milliseconds: 250));
expect(controller.value.caption.text, 'one');
await controller.seekTo(const Duration(milliseconds: 300));
expect(controller.value.caption.text, 'one');
await controller.seekTo(const Duration(milliseconds: 301));
expect(controller.value.caption.text, '');
await controller.seekTo(const Duration(milliseconds: 400));
expect(controller.value.caption.text, 'two');
await controller.seekTo(const Duration(milliseconds: 500));
expect(controller.value.caption.text, 'two');
await controller.seekTo(const Duration(milliseconds: 600));
expect(controller.value.caption.text, '');
await controller.seekTo(const Duration(milliseconds: 300));
expect(controller.value.caption.text, 'one');
});
test('setClosedCaptionFile loads caption file', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
expect(controller.closedCaptionFile, null);
await controller.setClosedCaptionFile(_loadClosedCaption());
expect(
(await controller.closedCaptionFile)!.captions,
(await _loadClosedCaption()).captions,
);
});
test('setClosedCaptionFile removes/changes caption file', () async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
closedCaptionFile: _loadClosedCaption(),
);
await controller.initialize();
expect(
(await controller.closedCaptionFile)!.captions,
(await _loadClosedCaption()).captions,
);
await controller.setClosedCaptionFile(null);
expect(controller.closedCaptionFile, null);
});
});
group('Platform callbacks', () {
testWidgets('playing completed', (WidgetTester tester) async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
const Duration nonzeroDuration = Duration(milliseconds: 100);
controller.value = controller.value.copyWith(duration: nonzeroDuration);
expect(controller.value.isPlaying, isFalse);
await controller.play();
expect(controller.value.isPlaying, isTrue);
final StreamController<VideoEvent> fakeVideoEventStream =
fakeVideoPlayerPlatform.streams[controller.textureId]!;
fakeVideoEventStream
.add(VideoEvent(eventType: VideoEventType.completed));
await tester.pumpAndSettle();
expect(controller.value.isPlaying, isFalse);
expect(controller.value.position, nonzeroDuration);
});
testWidgets('buffering status', (WidgetTester tester) async {
final VideoPlayerController controller = VideoPlayerController.network(
'https://127.0.0.1',
);
await controller.initialize();
expect(controller.value.isBuffering, false);
expect(controller.value.buffered, isEmpty);
final StreamController<VideoEvent> fakeVideoEventStream =
fakeVideoPlayerPlatform.streams[controller.textureId]!;
fakeVideoEventStream
.add(VideoEvent(eventType: VideoEventType.bufferingStart));
await tester.pumpAndSettle();
expect(controller.value.isBuffering, isTrue);
const Duration bufferStart = Duration.zero;
const Duration bufferEnd = Duration(milliseconds: 500);
fakeVideoEventStream.add(VideoEvent(
eventType: VideoEventType.bufferingUpdate,
buffered: <DurationRange>[
DurationRange(bufferStart, bufferEnd),
]));
await tester.pumpAndSettle();
expect(controller.value.isBuffering, isTrue);
expect(controller.value.buffered.length, 1);
expect(controller.value.buffered[0].toString(),
DurationRange(bufferStart, bufferEnd).toString());
fakeVideoEventStream
.add(VideoEvent(eventType: VideoEventType.bufferingEnd));
await tester.pumpAndSettle();
expect(controller.value.isBuffering, isFalse);
});
});
});
group('DurationRange', () {
test('uses given values', () {
const Duration start = Duration(seconds: 2);
const Duration end = Duration(seconds: 8);
final DurationRange range = DurationRange(start, end);
expect(range.start, start);
expect(range.end, end);
expect(range.toString(), contains('start: $start, end: $end'));
});
test('calculates fractions', () {
const Duration start = Duration(seconds: 2);
const Duration end = Duration(seconds: 8);
const Duration total = Duration(seconds: 10);
final DurationRange range = DurationRange(start, end);
expect(range.startFraction(total), .2);
expect(range.endFraction(total), .8);
});
});
group('VideoPlayerValue', () {
test('uninitialized()', () {
final VideoPlayerValue uninitialized = VideoPlayerValue.uninitialized();
expect(uninitialized.duration, equals(Duration.zero));
expect(uninitialized.position, equals(Duration.zero));
expect(uninitialized.caption, equals(Caption.none));
expect(uninitialized.captionOffset, equals(Duration.zero));
expect(uninitialized.buffered, isEmpty);
expect(uninitialized.isPlaying, isFalse);
expect(uninitialized.isLooping, isFalse);
expect(uninitialized.isBuffering, isFalse);
expect(uninitialized.volume, 1.0);
expect(uninitialized.playbackSpeed, 1.0);
expect(uninitialized.errorDescription, isNull);
expect(uninitialized.size, equals(Size.zero));
expect(uninitialized.isInitialized, isFalse);
expect(uninitialized.hasError, isFalse);
expect(uninitialized.aspectRatio, 1.0);
});
test('erroneous()', () {
const String errorMessage = 'foo';
final VideoPlayerValue error = VideoPlayerValue.erroneous(errorMessage);
expect(error.duration, equals(Duration.zero));
expect(error.position, equals(Duration.zero));
expect(error.caption, equals(Caption.none));
expect(error.captionOffset, equals(Duration.zero));
expect(error.buffered, isEmpty);
expect(error.isPlaying, isFalse);
expect(error.isLooping, isFalse);
expect(error.isBuffering, isFalse);
expect(error.volume, 1.0);
expect(error.playbackSpeed, 1.0);
expect(error.errorDescription, errorMessage);
expect(error.size, equals(Size.zero));
expect(error.isInitialized, isFalse);
expect(error.hasError, isTrue);
expect(error.aspectRatio, 1.0);
});
test('toString()', () {
const Duration duration = Duration(seconds: 5);
const Size size = Size(400, 300);
const Duration position = Duration(seconds: 1);
const Caption caption = Caption(
text: 'foo', number: 0, start: Duration.zero, end: Duration.zero);
const Duration captionOffset = Duration(milliseconds: 250);
final List<DurationRange> buffered = <DurationRange>[
DurationRange(Duration.zero, const Duration(seconds: 4))
];
const bool isInitialized = true;
const bool isPlaying = true;
const bool isLooping = true;
const bool isBuffering = true;
const double volume = 0.5;
const double playbackSpeed = 1.5;
final VideoPlayerValue value = VideoPlayerValue(
duration: duration,
size: size,
position: position,
caption: caption,
captionOffset: captionOffset,
buffered: buffered,
isInitialized: isInitialized,
isPlaying: isPlaying,
isLooping: isLooping,
isBuffering: isBuffering,
volume: volume,
playbackSpeed: playbackSpeed,
);
expect(
value.toString(),
'VideoPlayerValue(duration: 0:00:05.000000, '
'size: Size(400.0, 300.0), '
'position: 0:00:01.000000, '
'caption: Caption(number: 0, start: 0:00:00.000000, end: 0:00:00.000000, text: foo), '
'captionOffset: 0:00:00.250000, '
'buffered: [DurationRange(start: 0:00:00.000000, end: 0:00:04.000000)], '
'isInitialized: true, '
'isPlaying: true, '
'isLooping: true, '
'isBuffering: true, '
'volume: 0.5, '
'playbackSpeed: 1.5, '
'errorDescription: null)');
});
group('copyWith()', () {
test('exact copy', () {
final VideoPlayerValue original = VideoPlayerValue.uninitialized();
final VideoPlayerValue exactCopy = original.copyWith();
expect(exactCopy.toString(), original.toString());
});
test('errorDescription is not persisted when copy with null', () {
final VideoPlayerValue original = VideoPlayerValue.erroneous('error');
final VideoPlayerValue copy = original.copyWith(errorDescription: null);
expect(copy.errorDescription, null);
});
test('errorDescription is changed when copy with another error', () {
final VideoPlayerValue original = VideoPlayerValue.erroneous('error');
final VideoPlayerValue copy =
original.copyWith(errorDescription: 'new error');
expect(copy.errorDescription, 'new error');
});
test('errorDescription is changed when copy with error', () {
final VideoPlayerValue original = VideoPlayerValue.uninitialized();
final VideoPlayerValue copy =
original.copyWith(errorDescription: 'new error');
expect(copy.errorDescription, 'new error');
});
});
group('aspectRatio', () {
test('640x480 -> 4:3', () {
final VideoPlayerValue value = VideoPlayerValue(
isInitialized: true,
size: const Size(640, 480),
duration: const Duration(seconds: 1),
);
expect(value.aspectRatio, 4 / 3);
});
test('no size -> 1.0', () {
final VideoPlayerValue value = VideoPlayerValue(
isInitialized: true,
duration: const Duration(seconds: 1),
);
expect(value.aspectRatio, 1.0);
});
test('height = 0 -> 1.0', () {
final VideoPlayerValue value = VideoPlayerValue(
isInitialized: true,
size: const Size(640, 0),
duration: const Duration(seconds: 1),
);
expect(value.aspectRatio, 1.0);
});
test('width = 0 -> 1.0', () {
final VideoPlayerValue value = VideoPlayerValue(
isInitialized: true,
size: const Size(0, 480),
duration: const Duration(seconds: 1),
);
expect(value.aspectRatio, 1.0);
});
test('negative aspect ratio -> 1.0', () {
final VideoPlayerValue value = VideoPlayerValue(
isInitialized: true,
size: const Size(640, -480),
duration: const Duration(seconds: 1),
);
expect(value.aspectRatio, 1.0);
});
});
});
group('VideoPlayerOptions', () {
late FakeVideoPlayerPlatform fakeVideoPlayerPlatform;
setUp(() {
fakeVideoPlayerPlatform = FakeVideoPlayerPlatform();
VideoPlayerPlatform.instance = fakeVideoPlayerPlatform;
});
test('setMixWithOthers', () async {
final VideoPlayerController controller = VideoPlayerController.file(
File(''),
videoPlayerOptions: VideoPlayerOptions(mixWithOthers: true));
await controller.initialize();
expect(controller.videoPlayerOptions!.mixWithOthers, true);
});
test('true allowBackgroundPlayback continues playback', () async {
final VideoPlayerController controller = VideoPlayerController.file(
File(''),
videoPlayerOptions: VideoPlayerOptions(
allowBackgroundPlayback: true,
),
);
await controller.initialize();
await controller.play();
verifyPlayStateRespondsToLifecycle(
controller,
shouldPlayInBackground: true,
);
});
test('false allowBackgroundPlayback pauses playback', () async {
final VideoPlayerController controller = VideoPlayerController.file(
File(''),
videoPlayerOptions: VideoPlayerOptions(),
);
await controller.initialize();
await controller.play();
verifyPlayStateRespondsToLifecycle(
controller,
shouldPlayInBackground: false,
);
});
});
test('VideoProgressColors', () {
const Color playedColor = Color.fromRGBO(0, 0, 255, 0.75);
const Color bufferedColor = Color.fromRGBO(0, 255, 0, 0.5);
const Color backgroundColor = Color.fromRGBO(255, 255, 0, 0.25);
const VideoProgressColors colors = VideoProgressColors(
playedColor: playedColor,
bufferedColor: bufferedColor,
backgroundColor: backgroundColor);
expect(colors.playedColor, playedColor);
expect(colors.bufferedColor, bufferedColor);
expect(colors.backgroundColor, backgroundColor);
});
}
class FakeVideoPlayerPlatform extends VideoPlayerPlatform {
Completer<bool> initialized = Completer<bool>();
List<String> calls = <String>[];
List<DataSource> dataSources = <DataSource>[];
final Map<int, StreamController<VideoEvent>> streams =
<int, StreamController<VideoEvent>>{};
bool forceInitError = false;
int nextTextureId = 0;
final Map<int, Duration> _positions = <int, Duration>{};
@override
Future<int?> create(DataSource dataSource) async {
calls.add('create');
final StreamController<VideoEvent> stream = StreamController<VideoEvent>();
streams[nextTextureId] = stream;
if (forceInitError) {
stream.addError(PlatformException(
code: 'VideoError', message: 'Video player had error XYZ'));
} else {
stream.add(VideoEvent(
eventType: VideoEventType.initialized,
size: const Size(100, 100),
duration: const Duration(seconds: 1)));
}
dataSources.add(dataSource);
return nextTextureId++;
}
@override
Future<void> dispose(int textureId) async {
calls.add('dispose');
}
@override
Future<void> init() async {
calls.add('init');
initialized.complete(true);
}
@override
Stream<VideoEvent> videoEventsFor(int textureId) {
return streams[textureId]!.stream;
}
@override
Future<void> pause(int textureId) async {
calls.add('pause');
}
@override
Future<void> play(int textureId) async {
calls.add('play');
}
@override
Future<Duration> getPosition(int textureId) async {
calls.add('position');
return _positions[textureId] ?? Duration.zero;
}
@override
Future<void> seekTo(int textureId, Duration position) async {
calls.add('seekTo');
_positions[textureId] = position;
}
@override
Future<void> setLooping(int textureId, bool looping) async {
calls.add('setLooping');
}
@override
Future<void> setVolume(int textureId, double volume) async {
calls.add('setVolume');
}
@override
Future<void> setPlaybackSpeed(int textureId, double speed) async {
calls.add('setPlaybackSpeed');
}
@override
Future<void> setMixWithOthers(bool mixWithOthers) async {
calls.add('setMixWithOthers');
}
}
/// This allows a value of type T or T? to be treated as a value of type T?.
///
/// We use this so that APIs that have become non-nullable can still be used
/// with `!` and `?` on the stable branch.
T? _ambiguate<T>(T? value) => value;