Skip to content

F
Front-End
Commit 0295def2 authored by Dan Rubel's avatar Dan Rubel Committed by GitHub
Browse files
Options

Refactor DevFS for kernel code (#7529) 

Refactor DevFS so that it's easier to add new types of content such as kernel code
* add tests for DevFS package scanning
* add tests for DevFS over VMService protocol
* which covers _DevFSHttpWriter and ServiceProtocolDevFSOperations
* replace AssetBundleEntry and DevFSEntry with DevFSContent
* refactor to cleanup common code and replace some fields with locals
* rework .package file generation refactor away DevFSOperations.writeSource
* only update .package file if it has changed
* only write/delete/evict assets that have been changed/removed
parent 9573bc14
Show whitespace changes
Inline Side-by-side
Showing with 599 additions and 387 deletions
packages/flutter_tools/lib/src/asset.dart
View file @ 0295def2
......@@ -12,45 +12,20 @@ import 'package:yaml/yaml.dart';
import 'base/file_system.dart';
import 'build_info.dart';
import 'cache.dart';
import 'devfs.dart';
import 'dart/package_map.dart';
import 'globals.dart';
/// An entry in an asset bundle.
class AssetBundleEntry {
/// An entry backed by a File.
AssetBundleEntry.fromFile(this.archivePath, this.file)
: _contents = null;
/// An entry backed by a String.
AssetBundleEntry.fromString(this.archivePath, this._contents)
: file = null;
/// The path within the bundle.
final String archivePath;
/// The payload.
List<int> contentsAsBytes() {
if (_contents != null) {
return UTF8.encode(_contents);
} else {
return file.readAsBytesSync();
}
}
bool get isStringEntry => _contents != null;
int get contentsLength => _contents.length;
final File file;
final String _contents;
}
/// A bundle of assets.
class AssetBundle {
final Set<AssetBundleEntry> entries = new Set<AssetBundleEntry>();
final Map<String, DevFSContent> entries = <String, DevFSContent>{};
static const String defaultManifestPath = 'flutter.yaml';
static const String _kAssetManifestJson = 'AssetManifest.json';
static const String _kFontManifestJson = 'FontManifest.json';
static const String _kFontSetMaterial = 'material';
static const String _kFontSetRoboto = 'roboto';
static const String _kLICENSE = 'LICENSE';
bool _fixed = false;
DateTime _lastBuildTimestamp;
......@@ -73,8 +48,7 @@ class AssetBundle {
continue;
final String assetPath = path.join(projectRoot, asset);
final String archivePath = asset;
entries.add(
new AssetBundleEntry.fromFile(archivePath, fs.file(assetPath)));
entries[archivePath] = new DevFSFileContent(fs.file(assetPath));
}
}
......@@ -111,7 +85,7 @@ class AssetBundle {
}
if (manifest == null) {
// No manifest file found for this application.
entries.add(new AssetBundleEntry.fromString('AssetManifest.json', '{}'));
entries[_kAssetManifestJson] = new DevFSStringContent('{}');
return 0;
}
if (manifest != null) {
......@@ -141,16 +115,11 @@ class AssetBundle {
manifestDescriptor['uses-material-design'];
for (_Asset asset in assetVariants.keys) {
AssetBundleEntry assetEntry = _createAssetEntry(asset);
if (assetEntry == null)
return 1;
entries.add(assetEntry);
assert(asset.assetFileExists);
entries[asset.assetEntry] = new DevFSFileContent(asset.assetFile);
for (_Asset variant in assetVariants[asset]) {
AssetBundleEntry variantEntry = _createAssetEntry(variant);
if (variantEntry == null)
return 1;
entries.add(variantEntry);
assert(variant.assetFileExists);
entries[variant.assetEntry] = new DevFSFileContent(variant.assetFile);
}
}
......@@ -161,29 +130,27 @@ class AssetBundle {
materialAssets.addAll(_getMaterialAssets(_kFontSetRoboto));
}
for (_Asset asset in materialAssets) {
AssetBundleEntry assetEntry = _createAssetEntry(asset);
if (assetEntry == null)
return 1;
entries.add(assetEntry);
assert(asset.assetFileExists);
entries[asset.assetEntry] = new DevFSFileContent(asset.assetFile);
}
entries.add(_createAssetManifest(assetVariants));
entries[_kAssetManifestJson] = _createAssetManifest(assetVariants);
AssetBundleEntry fontManifest =
DevFSContent fontManifest =
_createFontManifest(manifestDescriptor, usesMaterialDesign, includeDefaultFonts, includeRobotoFonts);
if (fontManifest != null)
entries.add(fontManifest);
entries[_kFontManifestJson] = fontManifest;
// TODO(ianh): Only do the following line if we've changed packages or if our LICENSE file changed
entries.add(await _obtainLicenses(packageMap, assetBasePath, reportPackages: reportLicensedPackages));
entries[_kLICENSE] = await _obtainLicenses(packageMap, assetBasePath, reportPackages: reportLicensedPackages);
return 0;
}
void dump() {
printTrace('Dumping AssetBundle:');
for (AssetBundleEntry entry in entries) {
printTrace(entry.archivePath);
for (String archivePath in entries.keys.toList()..sort()) {
printTrace(archivePath);
}
}
}
......@@ -256,8 +223,8 @@ List<_Asset> _getMaterialAssets(String fontSet) {
final String _licenseSeparator = '\n' + ('-' * 80) + '\n';
/// Returns a AssetBundleEntry representing the license file.
Future<AssetBundleEntry> _obtainLicenses(
/// Returns a DevFSContent representing the license file.
Future<DevFSContent> _obtainLicenses(
PackageMap packageMap,
String assetBase,
{ bool reportPackages }
......@@ -323,17 +290,10 @@ Future<AssetBundleEntry> _obtainLicenses(
final String combinedLicenses = combinedLicensesList.join(_licenseSeparator);
return new AssetBundleEntry.fromString('LICENSE', combinedLicenses);
}
/// Create a [AssetBundleEntry] from the given [_Asset]; the asset must exist.
AssetBundleEntry _createAssetEntry(_Asset asset) {
assert(asset.assetFileExists);
return new AssetBundleEntry.fromFile(asset.assetEntry, asset.assetFile);
return new DevFSStringContent(combinedLicenses);
}
AssetBundleEntry _createAssetManifest(Map<_Asset, List<_Asset>> assetVariants) {
DevFSContent _createAssetManifest(Map<_Asset, List<_Asset>> assetVariants) {
Map<String, List<String>> json = <String, List<String>>{};
for (_Asset main in assetVariants.keys) {
List<String> variants = <String>[];
......@@ -341,10 +301,10 @@ AssetBundleEntry _createAssetManifest(Map<_Asset, List<_Asset>> assetVariants) {
variants.add(variant.relativePath);
json[main.relativePath] = variants;
}
return new AssetBundleEntry.fromString('AssetManifest.json', JSON.encode(json));
return new DevFSStringContent(JSON.encode(json));
}
AssetBundleEntry _createFontManifest(Map<String, dynamic> manifestDescriptor,
DevFSContent _createFontManifest(Map<String, dynamic> manifestDescriptor,
bool usesMaterialDesign,
bool includeDefaultFonts,
bool includeRobotoFonts) {
......@@ -358,7 +318,7 @@ AssetBundleEntry _createFontManifest(Map<String, dynamic> manifestDescriptor,
fonts.addAll(manifestDescriptor['fonts']);
if (fonts.isEmpty)
return null;
return new AssetBundleEntry.fromString('FontManifest.json', JSON.encode(fonts));
return new DevFSStringContent(JSON.encode(fonts));
}
/// Given an assetBase location and a flutter.yaml manifest, return a map of
......
packages/flutter_tools/lib/src/devfs.dart
View file @ 0295def2
......@@ -27,60 +27,45 @@ class DevFSConfig {
DevFSConfig get devFSConfig => context[DevFSConfig];
// A file that has been added to a DevFS.
class DevFSEntry {
DevFSEntry(this.devicePath, this.file)
: bundleEntry = null;
/// Common superclass for content copied to the device.
abstract class DevFSContent {
bool _exists = true;
DevFSEntry.bundle(this.devicePath, AssetBundleEntry bundleEntry)
: bundleEntry = bundleEntry,
file = bundleEntry.file;
/// Return `true` if this is the first time this method is called
/// or if the entry has been modified since this method was last called.
bool get isModified;
final String devicePath;
final AssetBundleEntry bundleEntry;
String get assetPath => bundleEntry.archivePath;
int get size;
Future<List<int>> contentsAsBytes();
Stream<List<int>> contentsAsStream();
Stream<List<int>> contentsAsCompressedStream() {
return contentsAsStream().transform(GZIP.encoder);
}
}
// File content to be copied to the device.
class DevFSFileContent extends DevFSContent {
DevFSFileContent(this.file);
final FileSystemEntity file;
FileSystemEntity _linkTarget;
FileStat _fileStat;
// When we scanned for files, did this still exist?
bool _exists = false;
DateTime get lastModified => _fileStat?.modified;
bool get _isSourceEntry => file == null;
bool get _isAssetEntry => bundleEntry != null;
bool get stillExists {
if (_isSourceEntry)
return true;
_stat();
return _fileStat.type != FileSystemEntityType.NOT_FOUND;
}
bool get isModified {
if (_isSourceEntry)
return true;
if (_fileStat == null) {
_stat();
return true;
}
FileStat _oldFileStat = _fileStat;
_stat();
return _fileStat.modified.isAfter(_oldFileStat.modified);
}
int get size {
if (_isSourceEntry) {
return bundleEntry.contentsLength;
} else {
if (_fileStat == null) {
_stat();
File _getFile() {
if (_linkTarget != null) {
return _linkTarget;
}
return _fileStat.size;
if (file is Link) {
// The link target.
return fs.file(file.resolveSymbolicLinksSync());
}
return file;
}
void _stat() {
if (_isSourceEntry)
return;
if (_linkTarget != null) {
// Stat the cached symlink target.
_fileStat = _linkTarget.statSync();
......@@ -99,48 +84,86 @@ class DevFSEntry {
}
}
File _getFile() {
if (_linkTarget != null) {
return _linkTarget;
}
if (file is Link) {
// The link target.
return fs.file(file.resolveSymbolicLinksSync());
@override
bool get isModified {
FileStat _oldFileStat = _fileStat;
_stat();
return _oldFileStat == null || _fileStat.modified.isAfter(_oldFileStat.modified);
}
return file;
@override
int get size {
if (_fileStat == null)
_stat();
return _fileStat.size;
}
Future<List<int>> contentsAsBytes() async {
if (_isSourceEntry)
return bundleEntry.contentsAsBytes();
final File file = _getFile();
return file.readAsBytes();
@override
Future<List<int>> contentsAsBytes() => _getFile().readAsBytes();
@override
Stream<List<int>> contentsAsStream() => _getFile().openRead();
}
/// Byte content to be copied to the device.
class DevFSByteContent extends DevFSContent {
DevFSByteContent(this._bytes);
List<int> _bytes;
bool _isModified = true;
List<int> get bytes => _bytes;
set bytes(List<int> newBytes) {
_bytes = newBytes;
_isModified = true;
}
Stream<List<int>> contentsAsStream() {
if (_isSourceEntry) {
return new Stream<List<int>>.fromIterable(
<List<int>>[bundleEntry.contentsAsBytes()]);
/// Return `true` only once so that the content is written to the device only once.
@override
bool get isModified {
bool modified = _isModified;
_isModified = false;
return modified;
}
final File file = _getFile();
return file.openRead();
@override
int get size => _bytes.length;
@override
Future<List<int>> contentsAsBytes() async => _bytes;
@override
Stream<List<int>> contentsAsStream() =>
new Stream<List<int>>.fromIterable(<List<int>>[_bytes]);
}
/// String content to be copied to the device.
class DevFSStringContent extends DevFSByteContent {
DevFSStringContent(String string) : _string = string, super(UTF8.encode(string));
String _string;
String get string => _string;
set string(String newString) {
_string = newString;
super.bytes = UTF8.encode(_string);
}
Stream<List<int>> contentsAsCompressedStream() {
return contentsAsStream().transform(GZIP.encoder);
@override
set bytes(List<int> newBytes) {
string = UTF8.decode(newBytes);
}
}
/// Abstract DevFS operations interface.
abstract class DevFSOperations {
Future<Uri> create(String fsName);
Future<dynamic> destroy(String fsName);
Future<dynamic> writeFile(String fsName, DevFSEntry entry);
Future<dynamic> deleteFile(String fsName, DevFSEntry entry);
Future<dynamic> writeSource(String fsName,
String devicePath,
String contents);
Future<dynamic> writeFile(String fsName, String devicePath, DevFSContent content);
Future<dynamic> deleteFile(String fsName, String devicePath);
}
/// An implementation of [DevFSOperations] that speaks to the
......@@ -163,10 +186,10 @@ class ServiceProtocolDevFSOperations implements DevFSOperations {
}
@override
Future<dynamic> writeFile(String fsName, DevFSEntry entry) async {
Future<dynamic> writeFile(String fsName, String devicePath, DevFSContent content) async {
List<int> bytes;
try {
bytes = await entry.contentsAsBytes();
bytes = await content.contentsAsBytes();
} catch (e) {
return e;
}
......@@ -175,31 +198,18 @@ class ServiceProtocolDevFSOperations implements DevFSOperations {
return await vmService.vm.invokeRpcRaw('_writeDevFSFile',
<String, dynamic> {
'fsName': fsName,
'path': entry.devicePath,
'path': devicePath,
'fileContents': fileContents
});
} catch (e) {
printTrace('DevFS: Failed to write ${entry.devicePath}: $e');
printTrace('DevFS: Failed to write $devicePath: $e');
}
}
@override
Future<dynamic> deleteFile(String fsName, DevFSEntry entry) async {
Future<dynamic> deleteFile(String fsName, String devicePath) async {
// TODO(johnmccutchan): Add file deletion to the devFS protocol.
}
@override
Future<dynamic> writeSource(String fsName,
String devicePath,
String contents) async {
String fileContents = BASE64.encode(UTF8.encode(contents));
return await vmService.vm.invokeRpcRaw('_writeDevFSFile',
<String, dynamic> {
'fsName': fsName,
'path': devicePath,
'fileContents': fileContents
});
}
}
class _DevFSHttpWriter {
......@@ -212,18 +222,18 @@ class _DevFSHttpWriter {
static const int kMaxInFlight = 6;
int _inFlight = 0;
List<DevFSEntry> _outstanding;
Map<String, DevFSContent> _outstanding;
Completer<Null> _completer;
HttpClient _client;
int _done;
int _max;
Future<Null> write(Set<DevFSEntry> entries,
Future<Null> write(Map<String, DevFSContent> entries,
{DevFSProgressReporter progressReporter}) async {
_client = new HttpClient();
_client.maxConnectionsPerHost = kMaxInFlight;
_completer = new Completer<Null>();
_outstanding = entries.toList();
_outstanding = new Map<String, DevFSContent>.from(entries);
_done = 0;
_max = _outstanding.length;
_scheduleWrites(progressReporter);
......@@ -237,26 +247,28 @@ class _DevFSHttpWriter {
// Finished.
break;
}
DevFSEntry entry = _outstanding.removeLast();
_scheduleWrite(entry, progressReporter);
String devicePath = _outstanding.keys.first;
DevFSContent content = _outstanding.remove(devicePath);
_scheduleWrite(devicePath, content, progressReporter);
_inFlight++;
}
}
Future<Null> _scheduleWrite(DevFSEntry entry,
Future<Null> _scheduleWrite(String devicePath,
DevFSContent content,
DevFSProgressReporter progressReporter) async {
try {
HttpClientRequest request = await _client.putUrl(httpAddress);
request.headers.removeAll(HttpHeaders.ACCEPT_ENCODING);
request.headers.add('dev_fs_name', fsName);
request.headers.add('dev_fs_path_b64',
BASE64.encode(UTF8.encode(entry.devicePath)));
Stream<List<int>> contents = entry.contentsAsCompressedStream();
BASE64.encode(UTF8.encode(devicePath)));
Stream<List<int>> contents = content.contentsAsCompressedStream();
await request.addStream(contents);
HttpClientResponse response = await request.close();
await response.drain();
} catch (e) {
printError('Error writing "${entry.devicePath}" to DevFS: $e');
printError('Error writing "$devicePath" to DevFS: $e');
}
if (progressReporter != null) {
_done++;
......@@ -300,16 +312,12 @@ class DevFS {
final String fsName;
final Directory rootDirectory;
String _packagesFilePath;
final Map<String, DevFSEntry> _entries = <String, DevFSEntry>{};
final Set<DevFSEntry> _dirtyEntries = new Set<DevFSEntry>();
final Set<DevFSEntry> _deletedEntries = new Set<DevFSEntry>();
final Set<DevFSEntry> dirtyAssetEntries = new Set<DevFSEntry>();
final Map<String, DevFSContent> _entries = <String, DevFSContent>{};
final Set<String> assetPathsToEvict = new Set<String>();
final List<Future<Map<String, dynamic>>> _pendingOperations =
new List<Future<Map<String, dynamic>>>();
int _bytes = 0;
int get bytes => _bytes;
Uri _baseUri;
Uri get baseUri => _baseUri;
......@@ -324,118 +332,88 @@ class DevFS {
return _operations.destroy(fsName);
}
void _reset() {
// Reset the dirty byte count.
_bytes = 0;
// Mark all entries as possibly deleted.
_entries.forEach((String path, DevFSEntry entry) {
entry._exists = false;
});
// Clear the dirt entries list.
_dirtyEntries.clear();
// Clear the deleted entries list.
_deletedEntries.clear();
// Clear the dirty asset entries.
dirtyAssetEntries.clear();
}
Future<dynamic> update({ DevFSProgressReporter progressReporter,
/// Update files on the device and return the number of bytes sync'd
Future<int> update({ DevFSProgressReporter progressReporter,
AssetBundle bundle,
bool bundleDirty: false,
Set<String> fileFilter}) async {
_reset();
// Mark all entries as possibly deleted.
for (DevFSContent content in _entries.values) {
content._exists = false;
}
// Scan workspace, packages, and assets
printTrace('DevFS: Starting sync from $rootDirectory');
logger.printTrace('Scanning project files');
Directory directory = rootDirectory;
await _scanDirectory(directory,
await _scanDirectory(rootDirectory,
recursive: true,
fileFilter: fileFilter);
printTrace('Scanning package files');
StringBuffer sb;
if (fs.isFileSync(_packagesFilePath)) {
PackageMap packageMap = new PackageMap(_packagesFilePath);
for (String packageName in packageMap.map.keys) {
Uri uri = packageMap.map[packageName];
// This project's own package.
final bool isProjectPackage = uri.toString() == 'lib/';
final String directoryName =
isProjectPackage ? 'lib' : 'packages/$packageName';
// If this is the project's package, we need to pass both
// package:<package_name> and lib/ as paths to be checked against
// the filter because we must support both package: imports and relative
// path imports within the project's own code.
final String packagesDirectoryName =
isProjectPackage ? 'packages/$packageName' : null;
Directory directory = fs.directory(uri);
bool packageExists =
await _scanDirectory(directory,
directoryName: directoryName,
recursive: true,
packagesDirectoryName: packagesDirectoryName,
fileFilter: fileFilter);
if (packageExists) {
sb ??= new StringBuffer();
sb.writeln('$packageName:$directoryName');
}
}
printTrace('Scanning package files');
await _scanPackages(fileFilter);
}
if (bundle != null) {
printTrace('Scanning asset files');
// Synchronize asset bundle.
for (AssetBundleEntry entry in bundle.entries) {
// We write the assets into the AssetBundle working dir so that they
// are in the same location in DevFS and the iOS simulator.
final String devicePath =
path.join(getAssetBuildDirectory(), entry.archivePath);
_scanBundleEntry(devicePath, entry, bundleDirty);
}
bundle.entries.forEach((String archivePath, DevFSContent content) {
_scanBundleEntry(archivePath, content, bundleDirty);
});
}
// Handle deletions.
printTrace('Scanning for deleted files');
String assetBuildDirPrefix = getAssetBuildDirectory() + path.separator;
final List<String> toRemove = new List<String>();
_entries.forEach((String path, DevFSEntry entry) {
if (!entry._exists) {
_deletedEntries.add(entry);
toRemove.add(path);
}
});
for (int i = 0; i < toRemove.length; i++) {
_entries.remove(toRemove[i]);
}
if (_deletedEntries.length > 0) {
printTrace('Removing deleted files');
for (DevFSEntry entry in _deletedEntries) {
_entries.forEach((String devicePath, DevFSContent content) {
if (!content._exists) {
Future<Map<String, dynamic>> operation =
_operations.deleteFile(fsName, entry);
_operations.deleteFile(fsName, devicePath);
if (operation != null)
_pendingOperations.add(operation);
toRemove.add(devicePath);
if (devicePath.startsWith(assetBuildDirPrefix)) {
String archivePath = devicePath.substring(assetBuildDirPrefix.length);
assetPathsToEvict.add(archivePath);
}
}
});
if (toRemove.isNotEmpty) {
printTrace('Removing deleted files');
toRemove.forEach(_entries.remove);
await Future.wait(_pendingOperations);
_pendingOperations.clear();
_deletedEntries.clear();
}
if (_dirtyEntries.length > 0) {
// Update modified files
int numBytes = 0;
Map<String, DevFSContent> dirtyEntries = <String, DevFSContent>{};
_entries.forEach((String devicePath, DevFSContent content) {
String archivePath;
if (devicePath.startsWith(assetBuildDirPrefix))
archivePath = devicePath.substring(assetBuildDirPrefix.length);
if (content.isModified || (bundleDirty && archivePath != null)) {
dirtyEntries[devicePath] = content;
numBytes += content.size;
if (archivePath != null)
assetPathsToEvict.add(archivePath);
}
});
if (dirtyEntries.length > 0) {
printTrace('Updating files');
if (_httpWriter != null) {
try {
await _httpWriter.write(_dirtyEntries,
await _httpWriter.write(dirtyEntries,
progressReporter: progressReporter);
} catch (e) {
printError("Could not update files on device: $e");
}
} else {
// Make service protocol requests for each.
for (DevFSEntry entry in _dirtyEntries) {
dirtyEntries.forEach((String devicePath, DevFSContent content) {
Future<Map<String, dynamic>> operation =
_operations.writeFile(fsName, entry);
_operations.writeFile(fsName, devicePath, content);
if (operation != null)
_pendingOperations.add(operation);
}
});
if (progressReporter != null) {
final int max = _pendingOperations.length;
int complete = 0;
......@@ -447,53 +425,24 @@ class DevFS {
await Future.wait(_pendingOperations, eagerError: true);
_pendingOperations.clear();
}
_dirtyEntries.clear();
}
if (sb != null)
await _operations.writeSource(fsName, '.packages', sb.toString());
printTrace('DevFS: Sync finished');
return numBytes;
}
void _scanFile(String devicePath, FileSystemEntity file) {
DevFSEntry entry = _entries[devicePath];
if (entry == null) {
// New file.
entry = new DevFSEntry(devicePath, file);
_entries[devicePath] = entry;
}
entry._exists = true;
bool needsWrite = entry.isModified;
if (needsWrite) {
if (_dirtyEntries.add(entry))
_bytes += entry.size;
}
}
void _scanBundleEntry(String devicePath,
AssetBundleEntry assetBundleEntry,
bool bundleDirty) {
DevFSEntry entry = _entries[devicePath];
if (entry == null) {
// New file.
entry = new DevFSEntry.bundle(devicePath, assetBundleEntry);
_entries[devicePath] = entry;
}
entry._exists = true;
if (!bundleDirty && assetBundleEntry.isStringEntry) {
// String bundle entries are synthetic files that only change if the
// bundle itself changes. Skip them if the bundle is not dirty.
return;
}
bool needsWrite = entry.isModified;
if (needsWrite) {
if (_dirtyEntries.add(entry)) {
_bytes += entry.size;
if (entry._isAssetEntry)
dirtyAssetEntries.add(entry);
}
DevFSContent content = _entries.putIfAbsent(devicePath, () => new DevFSFileContent(file));
content._exists = true;
}
void _scanBundleEntry(String archivePath, DevFSContent content, bool bundleDirty) {
// We write the assets into the AssetBundle working dir so that they
// are in the same location in DevFS and the iOS simulator.
final String devicePath = path.join(getAssetBuildDirectory(), archivePath);
_entries[devicePath] = content;
content._exists = true;
}
bool _shouldIgnore(String devicePath) {
......@@ -578,4 +527,42 @@ class DevFS {
}
return true;
}
Future<Null> _scanPackages(Set<String> fileFilter) async {
StringBuffer sb;
PackageMap packageMap = new PackageMap(_packagesFilePath);
for (String packageName in packageMap.map.keys) {
Uri uri = packageMap.map[packageName];
// This project's own package.
final bool isProjectPackage = uri.toString() == 'lib/';
final String directoryName =
isProjectPackage ? 'lib' : 'packages/$packageName';
// If this is the project's package, we need to pass both
// package:<package_name> and lib/ as paths to be checked against
// the filter because we must support both package: imports and relative
// path imports within the project's own code.
final String packagesDirectoryName =
isProjectPackage ? 'packages/$packageName' : null;
Directory directory = fs.directory(uri);
bool packageExists =
await _scanDirectory(directory,
directoryName: directoryName,
recursive: true,
packagesDirectoryName: packagesDirectoryName,
fileFilter: fileFilter);
if (packageExists) {
sb ??= new StringBuffer();
sb.writeln('$packageName:$directoryName');
}
}
if (sb != null) {
DevFSContent content = _entries['.packages'];
if (content is DevFSStringContent && content.string == sb.toString()) {
content._exists = true;
return;
}
_entries['.packages'] = new DevFSStringContent(sb.toString());
}
}
}
packages/flutter_tools/lib/src/flx.dart
View file @ 0295def2
......@@ -11,6 +11,7 @@ import 'base/common.dart';
import 'base/file_system.dart';
import 'base/process.dart';
import 'dart/package_map.dart';
import 'devfs.dart';
import 'build_info.dart';
import 'globals.dart';
import 'toolchain.dart';
......@@ -156,12 +157,12 @@ Future<Null> assemble({
zipBuilder.entries.addAll(assetBundle.entries);
if (snapshotFile != null)
zipBuilder.addEntry(new AssetBundleEntry.fromFile(_kSnapshotKey, snapshotFile));
zipBuilder.entries[_kSnapshotKey] = new DevFSFileContent(snapshotFile);
ensureDirectoryExists(outputPath);
printTrace('Encoding zip file to $outputPath');
zipBuilder.createZip(fs.file(outputPath), fs.directory(workingDirPath));
await zipBuilder.createZip(fs.file(outputPath), fs.directory(workingDirPath));
printTrace('Built $outputPath.');
}
packages/flutter_tools/lib/src/hot.dart
View file @ 0295def2
......@@ -273,7 +273,7 @@ class HotRunner extends ResidentRunner {
return false;
}
Status devFSStatus = logger.startProgress('Syncing files to device...');
await _devFS.update(progressReporter: progressReporter,
int bytes = await _devFS.update(progressReporter: progressReporter,
bundle: assetBundle,
bundleDirty: rebuildBundle,
fileFilter: _dartDependencies);
......@@ -282,18 +282,19 @@ class HotRunner extends ResidentRunner {
// Clear the set after the sync so they are recomputed next time.
_dartDependencies = null;
}
printTrace('Synced ${getSizeAsMB(_devFS.bytes)}.');
printTrace('Synced ${getSizeAsMB(bytes)}.');
return true;
}
Future<Null> _evictDirtyAssets() async {
if (_devFS.dirtyAssetEntries.length == 0)
if (_devFS.assetPathsToEvict.isEmpty)
return;
if (currentView.uiIsolate == null)
throw 'Application isolate not found';
for (DevFSEntry entry in _devFS.dirtyAssetEntries) {
await currentView.uiIsolate.flutterEvictAsset(entry.assetPath);
for (String assetPath in _devFS.assetPathsToEvict) {
await currentView.uiIsolate.flutterEvictAsset(assetPath);
}
_devFS.assetPathsToEvict.clear();
}
Future<Null> _cleanupDevFS() async {
......
packages/flutter_tools/lib/src/zip.dart
View file @ 0295def2
......@@ -2,10 +2,12 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'dart:async';
import 'package:archive/archive.dart';
import 'package:path/path.dart' as path;
import 'asset.dart';
import 'devfs.dart';
import 'base/file_system.dart';
import 'base/process.dart';
......@@ -20,27 +22,32 @@ abstract class ZipBuilder {
ZipBuilder._();
List<AssetBundleEntry> entries = <AssetBundleEntry>[];
void addEntry(AssetBundleEntry entry) => entries.add(entry);
Map<String, DevFSContent> entries = <String, DevFSContent>{};
void createZip(File outFile, Directory zipBuildDir);
Future<Null> createZip(File outFile, Directory zipBuildDir);
}
class _ArchiveZipBuilder extends ZipBuilder {
_ArchiveZipBuilder() : super._();
@override
void createZip(File outFile, Directory zipBuildDir) {
Future<Null> createZip(File outFile, Directory zipBuildDir) async {
Archive archive = new Archive();
for (AssetBundleEntry entry in entries) {
List<int> data = entry.contentsAsBytes();
archive.addFile(new ArchiveFile.noCompress(entry.archivePath, data.length, data));
}
final Completer<Null> finished = new Completer<Null>();
int count = entries.length;
entries.forEach((String archivePath, DevFSContent content) {
content.contentsAsBytes().then((List<int> data) {
archive.addFile(new ArchiveFile.noCompress(archivePath, data.length, data));
--count;
if (count == 0)
finished.complete();
});
});
await finished.future;
List<int> zipData = new ZipEncoder().encode(archive);
outFile.writeAsBytesSync(zipData);
await outFile.writeAsBytes(zipData);
}
}
......@@ -48,11 +55,11 @@ class _ZipToolBuilder extends ZipBuilder {
_ZipToolBuilder() : super._();
@override
void createZip(File outFile, Directory zipBuildDir) {
Future<Null> createZip(File outFile, Directory zipBuildDir) async {
// If there are no assets, then create an empty zip file.
if (entries.isEmpty) {
List<int> zipData = new ZipEncoder().encode(new Archive());
outFile.writeAsBytesSync(zipData);
await outFile.writeAsBytes(zipData);
return;
}
......@@ -63,23 +70,33 @@ class _ZipToolBuilder extends ZipBuilder {
zipBuildDir.deleteSync(recursive: true);
zipBuildDir.createSync(recursive: true);
for (AssetBundleEntry entry in entries) {
List<int> data = entry.contentsAsBytes();
File file = fs.file(path.join(zipBuildDir.path, entry.archivePath));
final Completer<Null> finished = new Completer<Null>();
int count = entries.length;
entries.forEach((String archivePath, DevFSContent content) {
content.contentsAsBytes().then((List<int> data) {
File file = fs.file(path.join(zipBuildDir.path, archivePath));
file.parent.createSync(recursive: true);
file.writeAsBytesSync(data);
}
if (_getCompressedNames().isNotEmpty) {
file.writeAsBytes(data).then((_) {
--count;
if (count == 0)
finished.complete();
});
});
});
await finished.future;
final Iterable<String> compressedNames = _getCompressedNames();
if (compressedNames.isNotEmpty) {
runCheckedSync(
<String>['zip', '-q', outFile.absolute.path]..addAll(_getCompressedNames()),
<String>['zip', '-q', outFile.absolute.path]..addAll(compressedNames),
workingDirectory: zipBuildDir.path
);
}
if (_getStoredNames().isNotEmpty) {
final Iterable<String> storedNames = _getStoredNames();
if (storedNames.isNotEmpty) {
runCheckedSync(
<String>['zip', '-q', '-0', outFile.absolute.path]..addAll(_getStoredNames()),
<String>['zip', '-q', '-0', outFile.absolute.path]..addAll(storedNames),
workingDirectory: zipBuildDir.path
);
}
......@@ -87,21 +104,14 @@ class _ZipToolBuilder extends ZipBuilder {
static const List<String> _kNoCompressFileExtensions = const <String>['.png', '.jpg'];
bool isAssetCompressed(AssetBundleEntry entry) {
bool isAssetCompressed(String archivePath) {
return !_kNoCompressFileExtensions.any(
(String extension) => entry.archivePath.endsWith(extension)
(String extension) => archivePath.endsWith(extension)
);
}
Iterable<String> _getCompressedNames() {
return entries
.where(isAssetCompressed)
.map((AssetBundleEntry entry) => entry.archivePath);
}
Iterable<String> _getCompressedNames() => entries.keys.where(isAssetCompressed);
Iterable<String> _getStoredNames() {
return entries
.where((AssetBundleEntry entry) => !isAssetCompressed(entry))
.map((AssetBundleEntry entry) => entry.archivePath);
}
Iterable<String> _getStoredNames() => entries.keys
.where((String archivePath) => !isAssetCompressed(archivePath));
}
packages/flutter_tools/test/asset_bundle_test.dart
View file @ 0295def2
......@@ -5,6 +5,7 @@
import 'dart:convert';
import 'package:flutter_tools/src/asset.dart';
import 'package:flutter_tools/src/base/file_system.dart';
import 'package:flutter_tools/src/devfs.dart';
import 'package:path/path.dart' as path;
import 'package:test/test.dart';
......@@ -37,29 +38,26 @@ void main() {
AssetBundle ab = new AssetBundle.fixed('', 'apple.txt');
expect(ab.entries, isNotEmpty);
expect(ab.entries.length, 1);
AssetBundleEntry entry = ab.entries.first;
expect(entry, isNotNull);
expect(entry.archivePath, 'apple.txt');
String archivePath = ab.entries.keys.first;
expect(archivePath, isNotNull);
expect(archivePath, 'apple.txt');
});
test('two entries', () async {
AssetBundle ab = new AssetBundle.fixed('', 'apple.txt,packages/flutter_gallery_assets/shrine/products/heels.png');
expect(ab.entries, isNotEmpty);
expect(ab.entries.length, 2);
AssetBundleEntry firstEntry = ab.entries.first;
expect(firstEntry, isNotNull);
expect(firstEntry.archivePath, 'apple.txt');
AssetBundleEntry lastEntry = ab.entries.last;
expect(lastEntry, isNotNull);
expect(lastEntry.archivePath, 'packages/flutter_gallery_assets/shrine/products/heels.png');
List<String> archivePaths = ab.entries.keys.toList()..sort();
expect(archivePaths[0], 'apple.txt');
expect(archivePaths[1], 'packages/flutter_gallery_assets/shrine/products/heels.png');
});
test('file contents', () async {
AssetBundle ab = new AssetBundle.fixed(projectRoot, assetPath);
expect(ab.entries, isNotEmpty);
expect(ab.entries.length, 1);
AssetBundleEntry entry = ab.entries.first;
expect(entry, isNotNull);
expect(entry.archivePath, assetPath);
expect(assetContents, UTF8.decode(entry.contentsAsBytes()));
String archivePath = ab.entries.keys.first;
DevFSContent content = ab.entries[archivePath];
expect(archivePath, assetPath);
expect(assetContents, UTF8.decode(await content.contentsAsBytes()));
});
});
......
packages/flutter_tools/test/devfs_test.dart
View file @ 0295def2
......@@ -2,10 +2,15 @@
// 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:convert';
import 'package:flutter_tools/src/asset.dart';
import 'package:flutter_tools/src/base/io.dart';
import 'package:flutter_tools/src/build_info.dart';
import 'package:flutter_tools/src/devfs.dart';
import 'package:flutter_tools/src/base/file_system.dart';
import 'package:flutter_tools/src/vmservice.dart';
import 'package:path/path.dart' as path;
import 'package:test/test.dart';
......@@ -14,72 +19,319 @@ import 'src/context.dart';
import 'src/mocks.dart';
void main() {
String filePath = 'bar/foo.txt';
String filePath2 = 'foo/bar.txt';
final String filePath = 'bar/foo.txt';
final String filePath2 = 'foo/bar.txt';
Directory tempDir;
String basePath;
MockDevFSOperations devFSOperations = new MockDevFSOperations();
DevFS devFS;
AssetBundle assetBundle = new AssetBundle();
assetBundle.entries.add(new AssetBundleEntry.fromString('a.txt', ''));
group('devfs', () {
testUsingContext('create local file system', () async {
tempDir = fs.systemTempDirectory.createTempSync();
final AssetBundle assetBundle = new AssetBundle();
group('DevFSContent', () {
test('bytes', () {
DevFSByteContent content = new DevFSByteContent(<int>[4, 5, 6]);
expect(content.bytes, orderedEquals(<int>[4, 5, 6]));
expect(content.isModified, isTrue);
expect(content.isModified, isFalse);
content.bytes = <int>[7, 8, 9, 2];
expect(content.bytes, orderedEquals(<int>[7, 8, 9, 2]));
expect(content.isModified, isTrue);
expect(content.isModified, isFalse);
});
test('string', () {
DevFSStringContent content = new DevFSStringContent('some string');
expect(content.string, 'some string');
expect(content.bytes, orderedEquals(UTF8.encode('some string')));
expect(content.isModified, isTrue);
expect(content.isModified, isFalse);
content.string = 'another string';
expect(content.string, 'another string');
expect(content.bytes, orderedEquals(UTF8.encode('another string')));
expect(content.isModified, isTrue);
expect(content.isModified, isFalse);
content.bytes = UTF8.encode('foo bar');
expect(content.string, 'foo bar');
expect(content.bytes, orderedEquals(UTF8.encode('foo bar')));
expect(content.isModified, isTrue);
expect(content.isModified, isFalse);
});
});
group('devfs local', () {
MockDevFSOperations devFSOperations = new MockDevFSOperations();
setUpAll(() {
tempDir = _newTempDir();
basePath = tempDir.path;
});
tearDownAll(_cleanupTempDirs);
testUsingContext('create dev file system', () async {
// simulate workspace
File file = fs.file(path.join(basePath, filePath));
await file.parent.create(recursive: true);
file.writeAsBytesSync(<int>[1, 2, 3]);
});
testUsingContext('create dev file system', () async {
// simulate package
await _createPackage('somepkg', 'somefile.txt');
devFS = new DevFS.operations(devFSOperations, 'test', tempDir);
await devFS.create();
expect(devFSOperations.contains('create test'), isTrue);
});
testUsingContext('populate dev file system', () async {
await devFS.update();
expect(devFSOperations.contains('writeFile test bar/foo.txt'), isTrue);
devFSOperations.expectMessages(<String>['create test']);
expect(devFS.assetPathsToEvict, isEmpty);
int bytes = await devFS.update();
devFSOperations.expectMessages(<String>[
'writeFile test .packages',
'writeFile test bar/foo.txt',
'writeFile test packages/somepkg/somefile.txt',
]);
expect(devFS.assetPathsToEvict, isEmpty);
expect(bytes, 31);
});
testUsingContext('add new file to local file system', () async {
File file = fs.file(path.join(basePath, filePath2));
await file.parent.create(recursive: true);
file.writeAsBytesSync(<int>[1, 2, 3, 4, 5, 6, 7]);
await devFS.update();
expect(devFSOperations.contains('writeFile test foo/bar.txt'), isTrue);
int bytes = await devFS.update();
devFSOperations.expectMessages(<String>[
'writeFile test foo/bar.txt',
]);
expect(devFS.assetPathsToEvict, isEmpty);
expect(bytes, 7);
});
testUsingContext('modify existing file on local file system', () async {
File file = fs.file(path.join(basePath, filePath));
// Set the last modified time to 5 seconds in the past.
updateFileModificationTime(file.path, new DateTime.now(), -5);
await devFS.update();
int bytes = await devFS.update();
devFSOperations.expectMessages(<String>[]);
expect(devFS.assetPathsToEvict, isEmpty);
expect(bytes, 0);
await file.writeAsBytes(<int>[1, 2, 3, 4, 5, 6]);
await devFS.update();
expect(devFSOperations.contains('writeFile test bar/foo.txt'), isTrue);
bytes = await devFS.update();
devFSOperations.expectMessages(<String>[
'writeFile test bar/foo.txt',
]);
expect(devFS.assetPathsToEvict, isEmpty);
expect(bytes, 6);
});
testUsingContext('delete a file from the local file system', () async {
File file = fs.file(path.join(basePath, filePath));
await file.delete();
await devFS.update();
expect(devFSOperations.contains('deleteFile test bar/foo.txt'), isTrue);
int bytes = await devFS.update();
devFSOperations.expectMessages(<String>[
'deleteFile test bar/foo.txt',
]);
expect(devFS.assetPathsToEvict, isEmpty);
expect(bytes, 0);
});
testUsingContext('add new package', () async {
await _createPackage('newpkg', 'anotherfile.txt');
int bytes = await devFS.update();
devFSOperations.expectMessages(<String>[
'writeFile test .packages',
'writeFile test packages/newpkg/anotherfile.txt',
]);
expect(devFS.assetPathsToEvict, isEmpty);
expect(bytes, 51);
});
testUsingContext('add an asset bundle', () async {
assetBundle.entries['a.txt'] = new DevFSStringContent('abc');
int bytes = await devFS.update(bundle: assetBundle, bundleDirty: true);
devFSOperations.expectMessages(<String>[
'writeFile test ${getAssetBuildDirectory()}/a.txt',
]);
expect(devFS.assetPathsToEvict, unorderedMatches(<String>['a.txt']));
devFS.assetPathsToEvict.clear();
expect(bytes, 3);
});
testUsingContext('add file in an asset bundle', () async {
await devFS.update(bundle: assetBundle, bundleDirty: true);
expect(devFSOperations.contains(
'writeFile test ${getAssetBuildDirectory()}/a.txt'), isTrue);
testUsingContext('add a file to the asset bundle - bundleDirty', () async {
assetBundle.entries['b.txt'] = new DevFSStringContent('abcd');
int bytes = await devFS.update(bundle: assetBundle, bundleDirty: true);
// Expect entire asset bundle written because bundleDirty is true
devFSOperations.expectMessages(<String>[
'writeFile test ${getAssetBuildDirectory()}/a.txt',
'writeFile test ${getAssetBuildDirectory()}/b.txt',
]);
expect(devFS.assetPathsToEvict, unorderedMatches(<String>[
'a.txt', 'b.txt']));
devFS.assetPathsToEvict.clear();
expect(bytes, 7);
});
testUsingContext('add a file to the asset bundle', () async {
assetBundle.entries.add(new AssetBundleEntry.fromString('b.txt', ''));
await devFS.update(bundle: assetBundle, bundleDirty: true);
expect(devFSOperations.contains(
'writeFile test ${getAssetBuildDirectory()}/b.txt'), isTrue);
assetBundle.entries['c.txt'] = new DevFSStringContent('12');
int bytes = await devFS.update(bundle: assetBundle);
devFSOperations.expectMessages(<String>[
'writeFile test ${getAssetBuildDirectory()}/c.txt',
]);
expect(devFS.assetPathsToEvict, unorderedMatches(<String>[
'c.txt']));
devFS.assetPathsToEvict.clear();
expect(bytes, 2);
});
testUsingContext('delete a file from the asset bundle', () async {
assetBundle.entries.remove('c.txt');
int bytes = await devFS.update(bundle: assetBundle);
devFSOperations.expectMessages(<String>[
'deleteFile test ${getAssetBuildDirectory()}/c.txt',
]);
expect(devFS.assetPathsToEvict, unorderedMatches(<String>['c.txt']));
devFS.assetPathsToEvict.clear();
expect(bytes, 0);
});
testUsingContext('delete all files from the asset bundle', () async {
assetBundle.entries.clear();
await devFS.update(bundle: assetBundle, bundleDirty: true);
expect(devFSOperations.contains(
'deleteFile test ${getAssetBuildDirectory()}/b.txt'), isTrue);
int bytes = await devFS.update(bundle: assetBundle, bundleDirty: true);
devFSOperations.expectMessages(<String>[
'deleteFile test ${getAssetBuildDirectory()}/a.txt',
'deleteFile test ${getAssetBuildDirectory()}/b.txt',
]);
expect(devFS.assetPathsToEvict, unorderedMatches(<String>[
'a.txt', 'b.txt'
]));
devFS.assetPathsToEvict.clear();
expect(bytes, 0);
});
testUsingContext('delete dev file system', () async {
await devFS.destroy();
devFSOperations.expectMessages(<String>['destroy test']);
expect(devFS.assetPathsToEvict, isEmpty);
});
});
group('devfs remote', () {
MockVMService vmService;
setUpAll(() async {
tempDir = _newTempDir();
basePath = tempDir.path;
vmService = new MockVMService();
await vmService.setUp();
});
tearDownAll(() async {
await vmService.tearDown();
_cleanupTempDirs();
});
testUsingContext('create dev file system', () async {
// simulate workspace
File file = fs.file(path.join(basePath, filePath));
await file.parent.create(recursive: true);
file.writeAsBytesSync(<int>[1, 2, 3]);
// simulate package
await _createPackage('somepkg', 'somefile.txt');
devFS = new DevFS(vmService, 'test', tempDir);
await devFS.create();
vmService.expectMessages(<String>['create test']);
expect(devFS.assetPathsToEvict, isEmpty);
int bytes = await devFS.update();
vmService.expectMessages(<String>[
'writeFile test .packages',
'writeFile test bar/foo.txt',
'writeFile test packages/somepkg/somefile.txt',
]);
expect(devFS.assetPathsToEvict, isEmpty);
expect(bytes, 31);
}, timeout: new Timeout(new Duration(seconds: 5)));
testUsingContext('delete dev file system', () async {
await devFS.destroy();
vmService.expectMessages(<String>['_deleteDevFS {fsName: test}']);
expect(devFS.assetPathsToEvict, isEmpty);
});
});
}
class MockVMService extends BasicMock implements VMService {
Uri _httpAddress;
HttpServer _server;
MockVM _vm;
MockVMService() {
_vm = new MockVM(this);
}
@override
Uri get httpAddress => _httpAddress;
@override
VM get vm => _vm;
Future<Null> setUp() async {
_server = await HttpServer.bind(InternetAddress.LOOPBACK_IP_V4, 0);
_httpAddress = Uri.parse('http://127.0.0.1:${_server.port}');
_server.listen((HttpRequest request) {
String fsName = request.headers.value('dev_fs_name');
String devicePath = UTF8.decode(BASE64.decode(request.headers.value('dev_fs_path_b64')));
messages.add('writeFile $fsName $devicePath');
request.drain().then((_) {
request.response
..write('Got it')
..close();
});
});
}
Future<Null> tearDown() async {
await _server.close();
}
@override
dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
}
class MockVM implements VM {
final MockVMService _service;
final Uri _baseUri = Uri.parse('file:///tmp/devfs/test');
MockVM(this._service);
@override
Future<Map<String, dynamic>> createDevFS(String fsName) async {
_service.messages.add('create $fsName');
return <String, dynamic>{'uri': '$_baseUri'};
}
@override
Future<Map<String, dynamic>> invokeRpcRaw(
String method, [Map<String, dynamic> params, Duration timeout]) async {
_service.messages.add('$method $params');
return <String, dynamic>{'success': true};
}
@override
dynamic noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
}
final List<Directory> _tempDirs = <Directory>[];
final Map <String, Directory> _packages = <String, Directory>{};
Directory _newTempDir() {
Directory tempDir = fs.systemTempDirectory.createTempSync('devfs${_tempDirs.length}');
_tempDirs.add(tempDir);
return tempDir;
}
void _cleanupTempDirs() {
while (_tempDirs.length > 0) {
_tempDirs.removeLast().deleteSync(recursive: true);
}
}
Future<Null> _createPackage(String pkgName, String pkgFileName) async {
final Directory pkgTempDir = _newTempDir();
File pkgFile = fs.file(path.join(pkgTempDir.path, pkgName, 'lib', pkgFileName));
await pkgFile.parent.create(recursive: true);
pkgFile.writeAsBytesSync(<int>[11, 12, 13]);
_packages[pkgName] = pkgTempDir;
StringBuffer sb = new StringBuffer();
_packages.forEach((String pkgName, Directory pkgTempDir) {
sb.writeln('$pkgName:${pkgTempDir.path}/$pkgName/lib');
});
fs.file(path.join(_tempDirs[0].path, '.packages')).writeAsStringSync(sb.toString());
}
packages/flutter_tools/test/src/mocks.dart
View file @ 0295def2
......@@ -13,6 +13,7 @@ import 'package:flutter_tools/src/ios/devices.dart';
import 'package:flutter_tools/src/ios/simulators.dart';
import 'package:flutter_tools/src/runner/flutter_command.dart';
import 'package:mockito/mockito.dart';
import 'package:test/test.dart';
class MockApplicationPackageStore extends ApplicationPackageStore {
MockApplicationPackageStore() : super(
......@@ -74,9 +75,16 @@ void applyMocksToCommand(FlutterCommand command) {
..commandValidator = () => true;
}
class MockDevFSOperations implements DevFSOperations {
/// Common functionality for tracking mock interaction
class BasicMock {
final List<String> messages = new List<String>();
void expectMessages(List<String> expectedMessages) {
List<String> actualMessages = new List<String>.from(messages);
messages.clear();
expect(actualMessages, unorderedEquals(expectedMessages));
}
bool contains(String match) {
print('Checking for `$match` in:');
print(messages);
......@@ -84,7 +92,9 @@ class MockDevFSOperations implements DevFSOperations {
messages.clear();
return result;
}
}
class MockDevFSOperations extends BasicMock implements DevFSOperations {
@override
Future<Uri> create(String fsName) async {
messages.add('create $fsName');
......@@ -97,19 +107,12 @@ class MockDevFSOperations implements DevFSOperations {
}
@override
Future<dynamic> writeFile(String fsName, DevFSEntry entry) async {
messages.add('writeFile $fsName ${entry.devicePath}');
}
@override
Future<dynamic> deleteFile(String fsName, DevFSEntry entry) async {
messages.add('deleteFile $fsName ${entry.devicePath}');
Future<dynamic> writeFile(String fsName, String devicePath, DevFSContent content) async {
messages.add('writeFile $fsName $devicePath');
}
@override
Future<dynamic> writeSource(String fsName,
String devicePath,
String contents) async {
messages.add('writeSource $fsName $devicePath');
Future<dynamic> deleteFile(String fsName, String devicePath) async {
messages.add('deleteFile $fsName $devicePath');
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment

HIAST - GitLab