Add back x_file type to file_selector

Author: mvanbeusekom

packages/file_selector/file_selector_platform_interface/lib/src/method_channel/method_channel_file_selector.dart

@@ -6,7 +6,6 @@ import 'package:flutter/services.dart';
 
 import 'package:file_selector_platform_interface/file_selector_platform_interface.dart';
 import 'package:meta/meta.dart';
-import 'package:x_file/x_file.dart';
 
 const MethodChannel _channel =
     MethodChannel('plugins.flutter.io/file_selector');

packages/file_selector/file_selector_platform_interface/lib/src/platform_interface/file_selector_interface.dart

@@ -6,7 +6,6 @@ import 'dart:async';
 
 import 'package:file_selector_platform_interface/file_selector_platform_interface.dart';
 import 'package:plugin_platform_interface/plugin_platform_interface.dart';
-import 'package:x_file/x_file.dart';
 
 import '../method_channel/method_channel_file_selector.dart';
 

packages/file_selector/file_selector_platform_interface/lib/src/types/types.dart

@@ -1 +1,3 @@
+export 'x_file/x_file.dart';
+
 export 'x_type_group/x_type_group.dart';

packages/file_selector/file_selector_platform_interface/lib/src/types/x_file/base.dart

@@ -0,0 +1,82 @@
+import 'dart:convert';
+import 'dart:typed_data';
+
+/// The interface for a XFile.
+///
+/// A XFile is a container that wraps the path of a selected
+/// file by the user and (in some platforms, like web) the bytes
+/// with the contents of the file.
+///
+/// This class is a very limited subset of dart:io [File], so all
+/// the methods should seem familiar.
+abstract class XFileBase {
+  /// Construct a XFile
+  XFileBase(String path);
+
+  /// Save the XFile at the indicated file path.
+  void saveTo(String path) async {
+    throw UnimplementedError('saveTo has not been implemented.');
+  }
+
+  /// Get the path of the picked file.
+  ///
+  /// This should only be used as a backwards-compatibility clutch
+  /// for mobile apps, or cosmetic reasons only (to show the user
+  /// the path they've picked).
+  ///
+  /// Accessing the data contained in the picked file by its path
+  /// is platform-dependant (and won't work on web), so use the
+  /// byte getters in the XFile instance instead.
+  String get path {
+    throw UnimplementedError('.path has not been implemented.');
+  }
+
+  /// The name of the file as it was selected by the user in their device.
+  ///
+  /// Use only for cosmetic reasons, do not try to use this as a path.
+  String get name {
+    throw UnimplementedError('.name has not been implemented.');
+  }
+
+  /// For web, it may be necessary for a file to know its MIME type.
+  String get mimeType {
+    throw UnimplementedError('.mimeType has not been implemented.');
+  }
+
+  /// Get the length of the file. Returns a `Future<int>` that completes with the length in bytes.
+  Future<int> length() {
+    throw UnimplementedError('.length() has not been implemented.');
+  }
+
+  /// Synchronously read the entire file contents as a string using the given [Encoding].
+  ///
+  /// By default, `encoding` is [utf8].
+  ///
+  /// Throws Exception if the operation fails.
+  Future<String> readAsString({Encoding encoding = utf8}) {
+    throw UnimplementedError('readAsString() has not been implemented.');
+  }
+
+  /// Synchronously read the entire file contents as a list of bytes.
+  ///
+  /// Throws Exception if the operation fails.
+  Future<Uint8List> readAsBytes() {
+    throw UnimplementedError('readAsBytes() has not been implemented.');
+  }
+
+  /// Create a new independent [Stream] for the contents of this file.
+  ///
+  /// If `start` is present, the file will be read from byte-offset `start`. Otherwise from the beginning (index 0).
+  ///
+  /// If `end` is present, only up to byte-index `end` will be read. Otherwise, until end of file.
+  ///
+  /// In order to make sure that system resources are freed, the stream must be read to completion or the subscription on the stream must be cancelled.
+  Stream<Uint8List> openRead([int start, int end]) {
+    throw UnimplementedError('openRead() has not been implemented.');
+  }
+
+  /// Get the last-modified time for the XFile
+  Future<DateTime> lastModified() {
+    throw UnimplementedError('openRead() has not been implemented.');
+  }
+}

packages/file_selector/file_selector_platform_interface/lib/src/types/x_file/html.dart

@@ -0,0 +1,132 @@
+import 'dart:convert';
+import 'dart:typed_data';
+
+import 'package:http/http.dart' as http show readBytes;
+import 'package:meta/meta.dart';
+import 'dart:html';
+
+import '../../web_helpers/web_helpers.dart';
+import './base.dart';
+
+/// A XFile that works on web.
+///
+/// It wraps the bytes of a selected file.
+class XFile extends XFileBase {
+  String path;
+
+  final String mimeType;
+  final Uint8List _data;
+  final int _length;
+  final String name;
+  final DateTime _lastModified;
+  Element _target;
+
+  final XFileTestOverrides _overrides;
+
+  bool get _hasTestOverrides => _overrides != null;
+
+  /// Construct a XFile object from its ObjectUrl.
+  ///
+  /// Optionally, this can be initialized with `bytes` and `length`
+  /// so no http requests are performed to retrieve files later.
+  ///
+  /// `name` needs to be passed from the outside, since we only have
+  /// access to it while we create the ObjectUrl.
+  XFile(
+    this.path, {
+    this.mimeType,
+    this.name,
+    int length,
+    Uint8List bytes,
+    DateTime lastModified,
+    @visibleForTesting XFileTestOverrides overrides,
+  })  : _data = bytes,
+        _length = length,
+        _overrides = overrides,
+        _lastModified = lastModified,
+        super(path);
+
+  /// Construct an XFile from its data
+  XFile.fromData(
+    Uint8List bytes, {
+    this.mimeType,
+    this.name,
+    int length,
+    DateTime lastModified,
+    this.path,
+    @visibleForTesting XFileTestOverrides overrides,
+  })  : _data = bytes,
+        _length = length,
+        _overrides = overrides,
+        _lastModified = lastModified,
+        super(path) {
+    if (path == null) {
+      final blob = (mimeType == null) ? Blob([bytes]) : Blob([bytes], mimeType);
+      this.path = Url.createObjectUrl(blob);
+    }
+  }
+
+  @override
+  Future<DateTime> lastModified() async {
+    if (_lastModified != null) {
+      return Future.value(_lastModified);
+    }
+    return null;
+  }
+
+  Future<Uint8List> get _bytes async {
+    if (_data != null) {
+      return Future.value(UnmodifiableUint8ListView(_data));
+    }
+    return http.readBytes(path);
+  }
+
+  @override
+  Future<int> length() async {
+    return _length ?? (await _bytes).length;
+  }
+
+  @override
+  Future<String> readAsString({Encoding encoding = utf8}) async {
+    return encoding.decode(await _bytes);
+  }
+
+  @override
+  Future<Uint8List> readAsBytes() async {
+    return Future.value(await _bytes);
+  }
+
+  @override
+  Stream<Uint8List> openRead([int start, int end]) async* {
+    final bytes = await _bytes;
+    yield bytes.sublist(start ?? 0, end ?? bytes.length);
+  }
+
+  /// Saves the data of this XFile at the location indicated by path.
+  /// For the web implementation, the path variable is ignored.
+  void saveTo(String path) async {
+    // Create a DOM container where we can host the anchor.
+    _target = ensureInitialized('__x_file_dom_element');
+
+    // Create an <a> tag with the appropriate download attributes and click it
+    // May be overridden with XFileTestOverrides
+    final AnchorElement element =
+        (_hasTestOverrides && _overrides.createAnchorElement != null)
+            ? _overrides.createAnchorElement(this.path, this.name)
+            : createAnchorElement(this.path, this.name);
+
+    // Clear the children in our container so we can add an element to click
+    _target.children.clear();
+    addElementToContainerAndClick(_target, element);
+  }
+}
+
+/// Overrides some functions to allow testing
+@visibleForTesting
+class XFileTestOverrides {
+  /// For overriding the creation of the file input element.
+  Element Function(String href, String suggestedName) createAnchorElement;
+
+  /// Default constructor for overrides
+  XFileTestOverrides({this.createAnchorElement});
+}

packages/file_selector/file_selector_platform_interface/lib/src/types/x_file/interface.dart

@@ -0,0 +1,54 @@
+import 'dart:typed_data';
+import 'package:meta/meta.dart';
+
+import './base.dart';
+
+/// A XFile is a cross-platform, simplified File abstraction.
+///
+/// It wraps the bytes of a selected file, and its (platform-dependant) path.
+class XFile extends XFileBase {
+  /// Construct a XFile object from its path.
+  ///
+  /// Optionally, this can be initialized with `bytes` and `length`
+  /// so no http requests are performed to retrieve data later.
+  ///
+  /// `name` may be passed from the outside, for those cases where the effective
+  /// `path` of the file doesn't match what the user sees when selecting it
+  /// (like in web)
+  XFile(
+    String path, {
+    String mimeType,
+    String name,
+    int length,
+    Uint8List bytes,
+    DateTime lastModified,
+    @visibleForTesting XFileTestOverrides overrides,
+  }) : super(path) {
+    throw UnimplementedError(
+        'XFile is not available in your current platform.');
+  }
+
+  /// Construct a XFile object from its data
+  XFile.fromData(
+    Uint8List bytes, {
+    String mimeType,
+    String name,
+    int length,
+    DateTime lastModified,
+    String path,
+    @visibleForTesting XFileTestOverrides overrides,
+  }) : super(path) {
+    throw UnimplementedError(
+        'XFile is not available in your current platform.');
+  }
+}
+
+/// Overrides some functions of XFile for testing purposes
+@visibleForTesting
+class XFileTestOverrides {
+  /// For overriding the creation of the file input element.
+  dynamic Function(String href, String suggestedName) createAnchorElement;
+
+  /// Default constructor for overrides
+  XFileTestOverrides({this.createAnchorElement});
+}