[video_player] Fixes issue where initialize() future stalls when failing to load source data and does not throw error.

slightfoot · slightfoot · commit 453094178b35 · 2019-11-19T17:01:15.000Z
Fix formatting.
Add tests for errors during init.
diff --git a/packages/video_player/lib/video_player.dart b/packages/video_player/lib/video_player.dart
@@ -274,6 +274,9 @@ class VideoPlayerController extends ValueNotifier<VideoPlayerValue> {
       final PlatformException e = obj;
       value = VideoPlayerValue.erroneous(e.message);
       _timer?.cancel();
+      if (!initializingCompleter.isCompleted) {
+        initializingCompleter.completeError(obj);
+      }
     }
 
     _eventSubscription = _eventChannelFor(_textureId)
diff --git a/packages/video_player/test/video_player_test.dart b/packages/video_player/test/video_player_test.dart
@@ -4,11 +4,12 @@
 
 import 'dart:async';
 import 'dart:io';
+
 import 'package:flutter/foundation.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter/widgets.dart';
-import 'package:video_player/video_player.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:video_player/video_player.dart';
 
 class FakeController extends ValueNotifier<VideoPlayerValue>
     implements VideoPlayerController {
@@ -24,23 +25,31 @@ class FakeController extends ValueNotifier<VideoPlayerValue>
 
   @override
   String get dataSource => '';
+
   @override
   DataSourceType get dataSourceType => DataSourceType.file;
+
   @override
   String get package => null;
+
   @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> initialize() async {}
+
   @override
   Future<void> pause() async {}
+
   @override
   Future<void> play() async {}
+
   @override
   Future<void> setLooping(bool looping) async {}
 
@@ -139,6 +148,20 @@ void main() {
         'uri': 'file://a.avi',
       });
     });
+
+    test('capture video initialization errors', () async {
+      final VideoPlayerController controller =
+          VideoPlayerController.network('http://testing.com/invalid_url');
+      try {
+        dynamic error;
+        fakeVideoPlayerPlatform.forceInitError = true;
+        await controller.initialize().catchError((dynamic e) => error = e);
+        final PlatformException platformEx = error;
+        expect(platformEx.code, equals('VideoError'));
+      } finally {
+        fakeVideoPlayerPlatform.forceInitError = false;
+      }
+    });
   });
 }
 
@@ -149,32 +172,40 @@ class FakeVideoPlayerPlatform {
 
   final MethodChannel _channel = const MethodChannel('flutter.io/videoPlayer');
 
-  Completer<bool> initialized = Completer<bool>();
-  List<Map<String, dynamic>> dataSourceDescriptions = <Map<String, dynamic>>[];
-  int nextTextureId = 0;
+  final Completer<bool> initialized = Completer<bool>();
+  final List<Map<String, dynamic>> dataSourceDescriptions =
+      <Map<String, dynamic>>[];
+
+  bool forceInitError = false;
+
+  int _nextTextureId = 0;
 
   Future<dynamic> onMethodCall(MethodCall call) {
     switch (call.method) {
       case 'init':
         initialized.complete(true);
         break;
       case 'create':
-        FakeVideoEventStream(
-            nextTextureId, 100, 100, const Duration(seconds: 1));
-        final Map<dynamic, dynamic> dataSource = call.arguments;
-        dataSourceDescriptions.add(dataSource.cast<String, dynamic>());
-        return Future<Map<String, int>>.sync(() {
-          return <String, int>{
-            'textureId': nextTextureId++,
-          };
-        });
+        {
+          FakeVideoEventStream(_nextTextureId, 100, 100,
+              const Duration(seconds: 1), forceInitError);
+          final Map<dynamic, dynamic> dataSource = call.arguments;
+          dataSourceDescriptions.add(dataSource.cast<String, dynamic>());
+          return Future<Map<String, int>>.sync(() {
+            return <String, int>{
+              'textureId': _nextTextureId++,
+            };
+          });
+        }
         break;
       case 'setLooping':
         break;
       case 'setVolume':
         break;
       case 'pause':
         break;
+      case 'dispose':
+        break;
       default:
         throw UnimplementedError(
             '${call.method} is not implemented by the FakeVideoPlayerPlatform');
@@ -184,54 +215,78 @@ class FakeVideoPlayerPlatform {
 }
 
 class FakeVideoEventStream {
-  FakeVideoEventStream(this.textureId, this.width, this.height, this.duration) {
-    eventsChannel = FakeEventsChannel(
-        'flutter.io/videoPlayer/videoEvents$textureId', onListen);
+  FakeVideoEventStream(this.textureId, this.width, this.height, this.duration,
+      this.initWithError) {
+    _eventsChannel = FakeEventsChannel(
+        'flutter.io/videoPlayer/videoEvents$textureId', onListen, onCancel);
   }
 
-  int textureId;
-  int width;
-  int height;
-  Duration duration;
-  FakeEventsChannel eventsChannel;
+  FakeEventsChannel _eventsChannel;
+  final int textureId;
+  final int width;
+  final int height;
+  final Duration duration;
+  final bool initWithError;
 
   void onListen() {
-    final Map<String, dynamic> initializedEvent = <String, dynamic>{
-      'event': 'initialized',
-      'duration': duration.inMilliseconds,
-      'width': width,
-      'height': height,
-    };
-    eventsChannel.sendEvent(initializedEvent);
+    if (!initWithError) {
+      _eventsChannel.sendEvent(<String, dynamic>{
+        'event': 'initialized',
+        'duration': duration.inMilliseconds,
+        'width': width,
+        'height': height,
+      });
+    } else {
+      _eventsChannel.sendError('VideoError', 'Video player had error XYZ');
+    }
+  }
+
+  void onCancel() {
+    //
   }
 }
 
 class FakeEventsChannel {
-  FakeEventsChannel(String name, this.onListen) {
+  FakeEventsChannel(String name, this.onListen, this.onCancel) {
     eventsMethodChannel = MethodChannel(name);
     eventsMethodChannel.setMockMethodCallHandler(onMethodCall);
   }
 
   MethodChannel eventsMethodChannel;
   VoidCallback onListen;
+  VoidCallback onCancel;
 
   Future<dynamic> onMethodCall(MethodCall call) {
     switch (call.method) {
       case 'listen':
         onListen();
         break;
+      case 'cancel':
+        eventsMethodChannel.setMockMethodCallHandler(null);
+        onCancel();
+        break;
     }
     return Future<void>.sync(() {});
   }
 
   void sendEvent(dynamic event) {
+    _sendMessage(const StandardMethodCodec().encodeSuccessEnvelope(event));
+  }
+
+  void sendError(String code, [String message, dynamic details]) {
+    _sendMessage(const StandardMethodCodec().encodeErrorEnvelope(
+      code: code,
+      message: message,
+      details: details,
+    ));
+  }
+
+  void _sendMessage(ByteData data) {
     // TODO(jackson): This has been deprecated and should be replaced
     // with `ServicesBinding.instance.defaultBinaryMessenger` when it's
     // available on all the versions of Flutter that we test.
     // ignore: deprecated_member_use
     defaultBinaryMessenger.handlePlatformMessage(
-        eventsMethodChannel.name,
-        const StandardMethodCodec().encodeSuccessEnvelope(event),
-        (ByteData data) {});
+        eventsMethodChannel.name, data, (ByteData data) {});
   }
 }

Original file line number	Diff line number	Diff line change
`@@ -274,6 +274,9 @@ class VideoPlayerController extends ValueNotifier<VideoPlayerValue> {`
`274`	`274`	`final PlatformException e = obj;`
`275`	`275`	`value = VideoPlayerValue.erroneous(e.message);`
`276`	`276`	`_timer?.cancel();`
	`277`	`+ if (!initializingCompleter.isCompleted) {`
	`278`	`+ initializingCompleter.completeError(obj);`
	`279`	`+ }`
`277`	`280`	`}`
`278`	`281`
`279`	`282`	`_eventSubscription = _eventChannelFor(_textureId)`