mirror of
https://github.com/flutter/flutter.git
synced 2025-06-03 00:51:18 +00:00

* Plumb a --strong option through to the front end server and the engine so that we can run flutter apps in preview-dart-2 and strong mode * - Address analyzer lint issues *- correctly set up strong mode option in the case of AOT builds
159 lines
5.2 KiB
Dart
159 lines
5.2 KiB
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:async';
|
|
|
|
import 'artifacts.dart';
|
|
import 'asset.dart';
|
|
import 'base/build.dart';
|
|
import 'base/common.dart';
|
|
import 'base/file_system.dart';
|
|
import 'build_info.dart';
|
|
import 'compile.dart';
|
|
import 'dart/package_map.dart';
|
|
import 'devfs.dart';
|
|
import 'globals.dart';
|
|
import 'zip.dart';
|
|
|
|
const String defaultMainPath = 'lib/main.dart';
|
|
const String defaultAssetBasePath = '.';
|
|
const String defaultManifestPath = 'pubspec.yaml';
|
|
String get defaultFlxOutputPath => fs.path.join(getBuildDirectory(), 'app.flx');
|
|
String get defaultSnapshotPath => fs.path.join(getBuildDirectory(), 'snapshot_blob.bin');
|
|
String get defaultDepfilePath => fs.path.join(getBuildDirectory(), 'snapshot_blob.bin.d');
|
|
const String defaultPrivateKeyPath = 'privatekey.der';
|
|
|
|
const String _kKernelKey = 'kernel_blob.bin';
|
|
const String _kSnapshotKey = 'snapshot_blob.bin';
|
|
const String _kDylibKey = 'libapp.so';
|
|
const String _kPlatformKernelKey = 'platform.dill';
|
|
|
|
Future<Null> build({
|
|
String mainPath: defaultMainPath,
|
|
String manifestPath: defaultManifestPath,
|
|
String outputPath,
|
|
String snapshotPath,
|
|
String depfilePath,
|
|
String privateKeyPath: defaultPrivateKeyPath,
|
|
String workingDirPath,
|
|
String packagesPath,
|
|
bool previewDart2 : false,
|
|
bool strongMode : false,
|
|
bool precompiledSnapshot: false,
|
|
bool reportLicensedPackages: false
|
|
}) async {
|
|
outputPath ??= defaultFlxOutputPath;
|
|
snapshotPath ??= defaultSnapshotPath;
|
|
depfilePath ??= defaultDepfilePath;
|
|
workingDirPath ??= getAssetBuildDirectory();
|
|
packagesPath ??= fs.path.absolute(PackageMap.globalPackagesPath);
|
|
File snapshotFile;
|
|
|
|
if (!precompiledSnapshot && !previewDart2) {
|
|
ensureDirectoryExists(snapshotPath);
|
|
|
|
// In a precompiled snapshot, the instruction buffer contains script
|
|
// content equivalents
|
|
final Snapshotter snapshotter = new Snapshotter();
|
|
final int result = await snapshotter.buildScriptSnapshot(
|
|
mainPath: mainPath,
|
|
snapshotPath: snapshotPath,
|
|
depfilePath: depfilePath,
|
|
packagesPath: packagesPath,
|
|
);
|
|
if (result != 0)
|
|
throwToolExit('Failed to run the Flutter compiler. Exit code: $result', exitCode: result);
|
|
|
|
snapshotFile = fs.file(snapshotPath);
|
|
}
|
|
|
|
DevFSContent kernelContent;
|
|
if (!precompiledSnapshot && previewDart2) {
|
|
final String kernelBinaryFilename = await compile(
|
|
sdkRoot: artifacts.getArtifactPath(Artifact.flutterPatchedSdkPath),
|
|
incrementalCompilerByteStorePath: fs.path.absolute(getIncrementalCompilerByteStoreDirectory()),
|
|
mainPath: fs.file(mainPath).absolute.path,
|
|
strongMode: strongMode
|
|
);
|
|
kernelContent = new DevFSFileContent(fs.file(kernelBinaryFilename));
|
|
}
|
|
|
|
return assemble(
|
|
manifestPath: manifestPath,
|
|
kernelContent: kernelContent,
|
|
snapshotFile: snapshotFile,
|
|
outputPath: outputPath,
|
|
privateKeyPath: privateKeyPath,
|
|
workingDirPath: workingDirPath,
|
|
packagesPath: packagesPath,
|
|
strongMode: strongMode,
|
|
reportLicensedPackages: reportLicensedPackages
|
|
).then((_) => null);
|
|
}
|
|
|
|
Future<List<String>> assemble({
|
|
String manifestPath,
|
|
DevFSContent kernelContent,
|
|
File snapshotFile,
|
|
File dylibFile,
|
|
String outputPath,
|
|
String privateKeyPath: defaultPrivateKeyPath,
|
|
String workingDirPath,
|
|
String packagesPath,
|
|
bool strongMode : false,
|
|
bool includeDefaultFonts: true,
|
|
bool reportLicensedPackages: false
|
|
}) async {
|
|
outputPath ??= defaultFlxOutputPath;
|
|
workingDirPath ??= getAssetBuildDirectory();
|
|
packagesPath ??= fs.path.absolute(PackageMap.globalPackagesPath);
|
|
printTrace('Building $outputPath');
|
|
|
|
// Build the asset bundle.
|
|
final AssetBundle assetBundle = new AssetBundle();
|
|
final int result = await assetBundle.build(
|
|
manifestPath: manifestPath,
|
|
workingDirPath: workingDirPath,
|
|
packagesPath: packagesPath,
|
|
includeDefaultFonts: includeDefaultFonts,
|
|
reportLicensedPackages: reportLicensedPackages
|
|
);
|
|
if (result != 0)
|
|
throwToolExit('Error building $outputPath: $result', exitCode: result);
|
|
|
|
final ZipBuilder zipBuilder = new ZipBuilder();
|
|
|
|
// Add all entries from the asset bundle.
|
|
zipBuilder.entries.addAll(assetBundle.entries);
|
|
|
|
final List<String> fileDependencies = assetBundle.entries.values
|
|
.expand((DevFSContent content) => content.fileDependencies)
|
|
.toList();
|
|
|
|
if (kernelContent != null) {
|
|
final String platformKernelDill = strongMode ?
|
|
artifacts.getArtifactPath(Artifact.platformKernelStrongDill) :
|
|
artifacts.getArtifactPath(Artifact.platformKernelDill);
|
|
zipBuilder.entries[_kKernelKey] = kernelContent;
|
|
zipBuilder.entries[_kPlatformKernelKey] = new DevFSFileContent(fs.file(platformKernelDill));
|
|
}
|
|
if (snapshotFile != null)
|
|
zipBuilder.entries[_kSnapshotKey] = new DevFSFileContent(snapshotFile);
|
|
if (dylibFile != null)
|
|
zipBuilder.entries[_kDylibKey] = new DevFSFileContent(dylibFile);
|
|
|
|
ensureDirectoryExists(outputPath);
|
|
|
|
printTrace('Encoding zip file to $outputPath');
|
|
|
|
// TODO(zarah): Remove the zipBuilder and write the files directly once FLX
|
|
// is deprecated.
|
|
|
|
await zipBuilder.createZip(fs.file(outputPath), fs.directory(workingDirPath));
|
|
|
|
printTrace('Built $outputPath.');
|
|
|
|
return fileDependencies;
|
|
}
|