[video_player] Add platform interface (flutter#2273)

* Move plugin to subdir

* Add video_player_platform_interface

* Make analyzer happy

* Improve documentation

* Bump version and update changelog

* Add stream of VideoEvent

* Ignore deprecated_member_use

* Improve changelog message and version

* Use DataSource class

* Add duration, size and buffering to VideoEvent

* Seek to Duration

* Fix buffering update

* Adapt docstring

* Add buildView

Author: cbenhagen

packages/video_player/CHANGELOG.md renamed to packages/video_player/video_player/CHANGELOG.md

@@ -2,8 +2,8 @@ name: video_player
 description: Flutter plugin for displaying inline video with other Flutter
   widgets on Android and iOS.
 author: Flutter Team <[email protected]>
-version: 0.10.3+1
-homepage: https://github.com/flutter/plugins/tree/master/packages/video_player
+version: 0.10.3+2
+homepage: https://github.com/flutter/plugins/tree/master/packages/video_player/video_player
 
 flutter:
   plugin:

packages/video_player/LICENSE renamed to packages/video_player/video_player/LICENSE

@@ -0,0 +1,27 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

packages/video_player/README.md renamed to packages/video_player/video_player/README.md

@@ -0,0 +1,178 @@
+// Copyright 2017 The Chromium 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:ui';
+
+import 'package:flutter/services.dart';
+import 'package:flutter/widgets.dart';
+
+import 'video_player_platform_interface.dart';
+
+const MethodChannel _channel = MethodChannel('flutter.io/videoPlayer');
+
+/// An implementation of [VideoPlayerPlatform] that uses method channels.
+class MethodChannelVideoPlayer extends VideoPlayerPlatform {
+  @override
+  Future<void> init() {
+    return _channel.invokeMethod<void>('init');
+  }
+
+  @override
+  Future<void> dispose(int textureId) {
+    return _channel.invokeMethod<void>(
+      'dispose',
+      <String, dynamic>{'textureId': textureId},
+    );
+  }
+
+  @override
+  Future<int> create(DataSource dataSource) async {
+    Map<String, dynamic> dataSourceDescription;
+
+    switch (dataSource.sourceType) {
+      case DataSourceType.asset:
+        dataSourceDescription = <String, dynamic>{
+          'asset': dataSource.asset,
+          'package': dataSource.package,
+        };
+        break;
+      case DataSourceType.network:
+        dataSourceDescription = <String, dynamic>{
+          'uri': dataSource.uri,
+          'formatHint': _videoFormatStringMap[dataSource.formatHint]
+        };
+        break;
+      case DataSourceType.file:
+        dataSourceDescription = <String, dynamic>{'uri': dataSource.uri};
+        break;
+    }
+
+    final Map<String, dynamic> response =
+        await _channel.invokeMapMethod<String, dynamic>(
+      'create',
+      dataSourceDescription,
+    );
+    return response['textureId'];
+  }
+
+  @override
+  Future<void> setLooping(int textureId, bool looping) {
+    return _channel.invokeMethod<void>(
+      'setLooping',
+      <String, dynamic>{
+        'textureId': textureId,
+        'looping': looping,
+      },
+    );
+  }
+
+  @override
+  Future<void> play(int textureId) {
+    return _channel.invokeMethod<void>(
+      'play',
+      <String, dynamic>{'textureId': textureId},
+    );
+  }
+
+  @override
+  Future<void> pause(int textureId) {
+    return _channel.invokeMethod<void>(
+      'pause',
+      <String, dynamic>{'textureId': textureId},
+    );
+  }
+
+  @override
+  Future<void> setVolume(int textureId, double volume) {
+    return _channel.invokeMethod<void>(
+      'setVolume',
+      <String, dynamic>{
+        'textureId': textureId,
+        'volume': volume,
+      },
+    );
+  }
+
+  @override
+  Future<void> seekTo(int textureId, Duration position) {
+    return _channel.invokeMethod<void>(
+      'seekTo',
+      <String, dynamic>{
+        'textureId': textureId,
+        'location': position.inMilliseconds,
+      },
+    );
+  }
+
+  @override
+  Future<Duration> getPosition(int textureId) async {
+    return Duration(
+      milliseconds: await _channel.invokeMethod<int>(
+        'position',
+        <String, dynamic>{'textureId': textureId},
+      ),
+    );
+  }
+
+  @override
+  Stream<VideoEvent> videoEventsFor(int textureId) {
+    return _eventChannelFor(textureId)
+        .receiveBroadcastStream()
+        .map((dynamic event) {
+      final Map<dynamic, dynamic> map = event;
+      switch (map['event']) {
+        case 'initialized':
+          return VideoEvent(
+            eventType: VideoEventType.initialized,
+            duration: Duration(milliseconds: map['duration']),
+            size: Size(map['width']?.toDouble() ?? 0.0,
+                map['height']?.toDouble() ?? 0.0),
+          );
+        case 'completed':
+          return VideoEvent(
+            eventType: VideoEventType.completed,
+          );
+        case 'bufferingUpdate':
+          final List<dynamic> values = map['values'];
+
+          return VideoEvent(
+            buffered: values.map<DurationRange>(_toDurationRange).toList(),
+            eventType: VideoEventType.completed,
+          );
+        case 'bufferingStart':
+          return VideoEvent(eventType: VideoEventType.bufferingStart);
+        case 'bufferingEnd':
+          return VideoEvent(eventType: VideoEventType.bufferingEnd);
+        default:
+          return VideoEvent(eventType: VideoEventType.unknown);
+      }
+    });
+  }
+
+  @override
+  Widget buildView(int textureId) {
+    return Texture(textureId: textureId);
+  }
+
+  EventChannel _eventChannelFor(int textureId) {
+    return EventChannel('flutter.io/videoPlayer/videoEvents$textureId');
+  }
+
+  static const Map<VideoFormat, String> _videoFormatStringMap =
+      <VideoFormat, String>{
+    VideoFormat.ss: 'ss',
+    VideoFormat.hls: 'hls',
+    VideoFormat.dash: 'dash',
+    VideoFormat.other: 'other',
+  };
+
+  DurationRange _toDurationRange(dynamic value) {
+    final List<dynamic> pair = value;
+    return DurationRange(
+      Duration(milliseconds: pair[0]),
+      Duration(milliseconds: pair[1]),
+    );
+  }
+}