273 lines
9.5 KiB
Dart
273 lines
9.5 KiB
Dart
// Copyright 2018 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:convert';
|
|
|
|
import 'android/gradle.dart' as gradle;
|
|
import 'base/file_system.dart';
|
|
import 'bundle.dart' as bundle;
|
|
import 'cache.dart';
|
|
import 'flutter_manifest.dart';
|
|
import 'ios/xcodeproj.dart' as xcode;
|
|
import 'plugins.dart';
|
|
import 'template.dart';
|
|
|
|
/// Represents the contents of a Flutter project at the specified [directory].
|
|
class FlutterProject {
|
|
|
|
FlutterProject(this.directory);
|
|
FlutterProject.fromPath(String projectPath) : directory = fs.directory(projectPath);
|
|
|
|
/// The location of this project.
|
|
final Directory directory;
|
|
|
|
Future<FlutterManifest> get manifest {
|
|
return _manifest ??= FlutterManifest.createFromPath(
|
|
directory.childFile(bundle.defaultManifestPath).path,
|
|
);
|
|
}
|
|
Future<FlutterManifest> _manifest;
|
|
|
|
/// Asynchronously returns the organization names found in this project as
|
|
/// part of iOS product bundle identifier, Android application ID, or
|
|
/// Gradle group ID.
|
|
Future<Set<String>> organizationNames() async {
|
|
final List<String> candidates = await Future.wait(<Future<String>>[
|
|
ios.productBundleIdentifier(),
|
|
android.applicationId(),
|
|
android.group(),
|
|
example.android.applicationId(),
|
|
example.ios.productBundleIdentifier(),
|
|
]);
|
|
return new Set<String>.from(
|
|
candidates.map(_organizationNameFromPackageName)
|
|
.where((String name) => name != null)
|
|
);
|
|
}
|
|
|
|
String _organizationNameFromPackageName(String packageName) {
|
|
if (packageName != null && 0 <= packageName.lastIndexOf('.'))
|
|
return packageName.substring(0, packageName.lastIndexOf('.'));
|
|
else
|
|
return null;
|
|
}
|
|
|
|
/// The iOS sub project of this project.
|
|
IosProject get ios => new IosProject(directory.childDirectory('ios'));
|
|
|
|
/// The Android sub project of this project.
|
|
AndroidProject get android => new AndroidProject(directory.childDirectory('android'));
|
|
|
|
/// The generated AndroidModule sub project of this module project.
|
|
AndroidModuleProject get androidModule => new AndroidModuleProject(directory.childDirectory('.android'));
|
|
|
|
/// The generated IosModule sub project of this module project.
|
|
IosModuleProject get iosModule => new IosModuleProject(directory.childDirectory('.ios'));
|
|
|
|
Future<File> get androidLocalPropertiesFile {
|
|
return _androidLocalPropertiesFile ??= manifest.then<File>((FlutterManifest manifest) {
|
|
return directory.childDirectory(manifest.isModule ? '.android' : 'android')
|
|
.childFile('local.properties');
|
|
});
|
|
}
|
|
Future<File> _androidLocalPropertiesFile;
|
|
|
|
Future<File> get generatedXcodePropertiesFile {
|
|
return _generatedXcodeProperties ??= manifest.then<File>((FlutterManifest manifest) {
|
|
return directory.childDirectory(manifest.isModule ? '.ios' : 'ios')
|
|
.childDirectory('Flutter')
|
|
.childFile('Generated.xcconfig');
|
|
});
|
|
}
|
|
Future<File> _generatedXcodeProperties;
|
|
|
|
File get flutterPluginsFile {
|
|
return _flutterPluginsFile ??= directory.childFile('.flutter-plugins');
|
|
}
|
|
File _flutterPluginsFile;
|
|
|
|
Future<Directory> get androidPluginRegistrantHost async {
|
|
return _androidPluginRegistrantHost ??= manifest.then((FlutterManifest manifest) {
|
|
if (manifest.isModule) {
|
|
return directory.childDirectory('.android').childDirectory('Flutter');
|
|
} else {
|
|
return directory.childDirectory('android').childDirectory('app');
|
|
}
|
|
});
|
|
}
|
|
Future<Directory> _androidPluginRegistrantHost;
|
|
|
|
Future<Directory> get iosPluginRegistrantHost async {
|
|
return _iosPluginRegistrantHost ??= manifest.then((FlutterManifest manifest) {
|
|
if (manifest.isModule) {
|
|
// In a module create the GeneratedPluginRegistrant as a pod to be included
|
|
// from a hosting app.
|
|
return directory
|
|
.childDirectory('.ios')
|
|
.childDirectory('Flutter')
|
|
.childDirectory('FlutterPluginRegistrant');
|
|
} else {
|
|
// For a non-module create the GeneratedPluginRegistrant as source files
|
|
// directly in the iOS project.
|
|
return directory.childDirectory('ios').childDirectory('Runner');
|
|
}
|
|
});
|
|
}
|
|
Future<Directory> _iosPluginRegistrantHost;
|
|
|
|
/// Returns true if this project has an example application
|
|
bool get hasExampleApp => _exampleDirectory.childFile('pubspec.yaml').existsSync();
|
|
|
|
/// The example sub project of this (package or plugin) project.
|
|
FlutterProject get example => new FlutterProject(_exampleDirectory);
|
|
|
|
/// The directory that will contain the example if an example exists.
|
|
Directory get _exampleDirectory => directory.childDirectory('example');
|
|
|
|
/// Generates project files necessary to make Gradle builds work on Android
|
|
/// and CocoaPods+Xcode work on iOS, for app and module projects only.
|
|
///
|
|
/// Returns the number of files written.
|
|
Future<void> ensureReadyForPlatformSpecificTooling() async {
|
|
if (!directory.existsSync() || hasExampleApp) {
|
|
return 0;
|
|
}
|
|
final FlutterManifest manifest = await this.manifest;
|
|
if (manifest.isModule) {
|
|
await androidModule.ensureReadyForPlatformSpecificTooling(this);
|
|
await iosModule.ensureReadyForPlatformSpecificTooling();
|
|
}
|
|
await xcode.generateXcodeProperties(project: this);
|
|
await injectPlugins(this);
|
|
}
|
|
}
|
|
|
|
/// Represents the contents of the ios/ folder of a Flutter project.
|
|
class IosProject {
|
|
static final RegExp _productBundleIdPattern = new RegExp(r'^\s*PRODUCT_BUNDLE_IDENTIFIER\s*=\s*(.*);\s*$');
|
|
IosProject(this.directory);
|
|
|
|
final Directory directory;
|
|
|
|
/// The xcode config file for [mode].
|
|
File xcodeConfigFor(String mode) {
|
|
return directory.childDirectory('Flutter').childFile('$mode.xcconfig');
|
|
}
|
|
|
|
/// The 'Podfile'.
|
|
File get podfile => directory.childFile('Podfile');
|
|
|
|
/// The 'Podfile.lock'.
|
|
File get podfileLock => directory.childFile('Podfile.lock');
|
|
|
|
/// The 'Manifest.lock'.
|
|
File get podManifestLock => directory.childDirectory('Pods').childFile('Manifest.lock');
|
|
|
|
Future<String> productBundleIdentifier() {
|
|
final File projectFile = directory.childDirectory('Runner.xcodeproj').childFile('project.pbxproj');
|
|
return _firstMatchInFile(projectFile, _productBundleIdPattern).then((Match match) => match?.group(1));
|
|
}
|
|
}
|
|
|
|
/// Represents the contents of the .ios/ folder of a Flutter module
|
|
/// project.
|
|
class IosModuleProject {
|
|
IosModuleProject(this.directory);
|
|
|
|
final Directory directory;
|
|
|
|
Future<void> ensureReadyForPlatformSpecificTooling() async {
|
|
if (_shouldRegenerate()) {
|
|
final Template template = new Template.fromName(fs.path.join('module', 'ios'));
|
|
template.render(directory, <String, dynamic>{}, printStatusWhenWriting: false);
|
|
}
|
|
}
|
|
|
|
bool _shouldRegenerate() {
|
|
return Cache.instance.fileOlderThanToolsStamp(directory.childFile('podhelper.rb'));
|
|
}
|
|
}
|
|
|
|
/// Represents the contents of the android/ folder of a Flutter project.
|
|
class AndroidProject {
|
|
static final RegExp _applicationIdPattern = new RegExp('^\\s*applicationId\\s+[\'\"](.*)[\'\"]\\s*\$');
|
|
static final RegExp _groupPattern = new RegExp('^\\s*group\\s+[\'\"](.*)[\'\"]\\s*\$');
|
|
|
|
AndroidProject(this.directory);
|
|
|
|
File get gradleManifestFile {
|
|
return _gradleManifestFile ??= isUsingGradle()
|
|
? fs.file(fs.path.join(directory.path, 'app', 'src', 'main', 'AndroidManifest.xml'))
|
|
: directory.childFile('AndroidManifest.xml');
|
|
}
|
|
File _gradleManifestFile;
|
|
|
|
|
|
File get gradleAppOutV1File {
|
|
return _gradleAppOutV1File ??= gradleAppOutV1Directory.childFile('app-debug.apk');
|
|
}
|
|
File _gradleAppOutV1File;
|
|
|
|
Directory get gradleAppOutV1Directory {
|
|
return _gradleAppOutV1Directory ??= fs.directory(fs.path.join(directory.path, 'app', 'build', 'outputs', 'apk'));
|
|
}
|
|
Directory _gradleAppOutV1Directory;
|
|
|
|
|
|
bool isUsingGradle() {
|
|
return directory.childFile('build.gradle').existsSync();
|
|
}
|
|
|
|
final Directory directory;
|
|
|
|
Future<String> applicationId() {
|
|
final File gradleFile = directory.childDirectory('app').childFile('build.gradle');
|
|
return _firstMatchInFile(gradleFile, _applicationIdPattern).then((Match match) => match?.group(1));
|
|
}
|
|
|
|
Future<String> group() {
|
|
final File gradleFile = directory.childFile('build.gradle');
|
|
return _firstMatchInFile(gradleFile, _groupPattern).then((Match match) => match?.group(1));
|
|
}
|
|
}
|
|
|
|
/// Represents the contents of the .android-generated/ folder of a Flutter module
|
|
/// project.
|
|
class AndroidModuleProject {
|
|
AndroidModuleProject(this.directory);
|
|
|
|
final Directory directory;
|
|
|
|
Future<void> ensureReadyForPlatformSpecificTooling(FlutterProject project) async {
|
|
if (_shouldRegenerate()) {
|
|
final Template template = new Template.fromName(fs.path.join('module', 'android'));
|
|
template.render(directory, <String, dynamic>{
|
|
'androidIdentifier': (await project.manifest).moduleDescriptor['androidPackage'],
|
|
}, printStatusWhenWriting: false);
|
|
gradle.injectGradleWrapper(directory);
|
|
}
|
|
await gradle.updateLocalProperties(project: project, requireAndroidSdk: false);
|
|
}
|
|
|
|
bool _shouldRegenerate() {
|
|
return Cache.instance.fileOlderThanToolsStamp(directory.childFile('build.gradle'));
|
|
}
|
|
}
|
|
|
|
/// Asynchronously returns the first line-based match for [regExp] in [file].
|
|
///
|
|
/// Assumes UTF8 encoding.
|
|
Future<Match> _firstMatchInFile(File file, RegExp regExp) async {
|
|
if (!await file.exists()) {
|
|
return null;
|
|
}
|
|
return file
|
|
.openRead()
|
|
.transform(utf8.decoder)
|
|
.transform(const LineSplitter())
|
|
.map(regExp.firstMatch)
|
|
.firstWhere((Match match) => match != null, orElse: () => null);
|
|
}
|