Move home.dart into example/demo_launcher

sky/tools/skyx/bin/skyx.dart

 // Copyright 2015 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:io';
 import 'dart:async';
 
 import 'package:archive/archive.dart';
 import 'package:args/args.dart';
 import 'package:yaml/yaml.dart';
 
 const String kSnapshotKey = 'snapshot_blob.bin';
 const List<String> kDensities = const ['drawable-xxhdpi'];
 const List<String> kThemes = const ['white', 'black', 'grey600'];
 const List<int> kSizes = const [24];
 
+class Asset {
+  final String base;
+  final String key;
+
+  Asset({ this.base, this.key });
+}
+
+Iterable<Asset> parseAssets(Map manifestDescriptor, String manifestPath) sync* {
+  if (manifestDescriptor == null || !manifestDescriptor.containsKey('assets'))
+    return;
+  String basePath = new File(manifestPath).parent.path;
+  for (String asset in manifestDescriptor['assets'])
+    yield new Asset(base: basePath, key: asset);
+}
+
 class MaterialAsset {
   final String name;
   final String density;
   final String theme;
   final int size;
 
   MaterialAsset(Map descriptor)
     : name = descriptor['name'],
       density = descriptor['density'],
       theme = descriptor['theme'],
@@ skipping 37 matching lines @@
   }
 }
 
 Future loadManifest(String manifestPath) async {
   if (manifestPath == null)
     return null;
   String manifestDescriptor = await new File(manifestPath).readAsString();
   return loadYaml(manifestDescriptor);
 }
 
-Future<ArchiveFile> createFile(MaterialAsset asset, String assetBase) async {
-  File file = new File('${assetBase}/${asset.key}');
+Future<ArchiveFile> createFile(String key, String assetBase) async {
+  File file = new File('${assetBase}/${key}');
   List<int> content = await file.readAsBytes();
-  return new ArchiveFile.noCompress(asset.key, content.length, content);
+  return new ArchiveFile.noCompress(key, content.length, content);
 }
 
 Future<ArchiveFile> createSnapshotFile(String snapshotPath) async {
   File file = new File(snapshotPath);
   List<int> content = await file.readAsBytes();
   return new ArchiveFile(kSnapshotKey, content.length, content);
 }
 
 main(List<String> argv) async {
   ArgParser parser = new ArgParser();
   parser.addFlag('help', abbr: 'h', negatable: false);
   parser.addOption('asset-base');
   parser.addOption('manifest');
   parser.addOption('output-file', abbr: 'o');
   parser.addOption('snapshot');
 
   ArgResults args = parser.parse(argv);
   if (args['help']) {
     print(parser.usage);
     return;
   }
 
   String manifestPath = args['manifest'];
   Map manifestDescriptor = await loadManifest(manifestPath);
+  Iterable<Asset> assets = parseAssets(manifestDescriptor, manifestPath);
   Iterable<MaterialAsset> materialAssets = parseMaterialAssets(manifestDescriptor);
 
   Archive archive = new Archive();
 
   String snapshot = args['snapshot'];
   if (snapshot != null)
     archive.addFile(await createSnapshotFile(snapshot));
 
+  for (Asset asset in assets)
+    archive.addFile(await createFile(asset.key, asset.base));
+
   for (MaterialAsset asset in materialAssets)
-    archive.addFile(await createFile(asset, args['asset-base']));
+    archive.addFile(await createFile(asset.key, args['asset-base']));
 
   File outputFile = new File(args['output-file']);
   await outputFile.writeAsBytes(new ZipEncoder().encode(archive));
 }