| // Copyright 2014 The Flutter 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 'package:meta/meta.dart'; |
| import 'package:xml/xml.dart' as xml; |
| import 'package:yaml/yaml.dart'; |
| |
| import 'android/gradle_utils.dart' as gradle; |
| import 'artifacts.dart'; |
| import 'base/common.dart'; |
| import 'base/context.dart'; |
| import 'base/file_system.dart'; |
| import 'build_info.dart'; |
| import 'bundle.dart' as bundle; |
| import 'features.dart'; |
| import 'flutter_manifest.dart'; |
| import 'globals.dart' as globals; |
| import 'ios/plist_parser.dart'; |
| import 'ios/xcodeproj.dart' as xcode; |
| import 'platform_plugins.dart'; |
| import 'plugins.dart'; |
| import 'template.dart'; |
| |
| FlutterProjectFactory get projectFactory => context.get<FlutterProjectFactory>() ?? FlutterProjectFactory(); |
| |
| class FlutterProjectFactory { |
| FlutterProjectFactory(); |
| |
| @visibleForTesting |
| final Map<String, FlutterProject> projects = |
| <String, FlutterProject>{}; |
| |
| /// Returns a [FlutterProject] view of the given directory or a ToolExit error, |
| /// if `pubspec.yaml` or `example/pubspec.yaml` is invalid. |
| FlutterProject fromDirectory(Directory directory) { |
| assert(directory != null); |
| return projects.putIfAbsent(directory.path, /* ifAbsent */ () { |
| final FlutterManifest manifest = FlutterProject._readManifest( |
| directory.childFile(bundle.defaultManifestPath).path, |
| ); |
| final FlutterManifest exampleManifest = FlutterProject._readManifest( |
| FlutterProject._exampleDirectory(directory) |
| .childFile(bundle.defaultManifestPath) |
| .path, |
| ); |
| return FlutterProject(directory, manifest, exampleManifest); |
| }); |
| } |
| } |
| |
| /// Represents the contents of a Flutter project at the specified [directory]. |
| /// |
| /// [FlutterManifest] information is read from `pubspec.yaml` and |
| /// `example/pubspec.yaml` files on construction of a [FlutterProject] instance. |
| /// The constructed instance carries an immutable snapshot representation of the |
| /// presence and content of those files. Accordingly, [FlutterProject] instances |
| /// should be discarded upon changes to the `pubspec.yaml` files, but can be |
| /// used across changes to other files, as no other file-level information is |
| /// cached. |
| class FlutterProject { |
| @visibleForTesting |
| FlutterProject(this.directory, this.manifest, this._exampleManifest) |
| : assert(directory != null), |
| assert(manifest != null), |
| assert(_exampleManifest != null); |
| |
| /// Returns a [FlutterProject] view of the given directory or a ToolExit error, |
| /// if `pubspec.yaml` or `example/pubspec.yaml` is invalid. |
| static FlutterProject fromDirectory(Directory directory) => projectFactory.fromDirectory(directory); |
| |
| /// Returns a [FlutterProject] view of the current directory or a ToolExit error, |
| /// if `pubspec.yaml` or `example/pubspec.yaml` is invalid. |
| static FlutterProject current() => fromDirectory(globals.fs.currentDirectory); |
| |
| /// Returns a [FlutterProject] view of the given directory or a ToolExit error, |
| /// if `pubspec.yaml` or `example/pubspec.yaml` is invalid. |
| static FlutterProject fromPath(String path) => fromDirectory(globals.fs.directory(path)); |
| |
| /// The location of this project. |
| final Directory directory; |
| |
| /// The manifest of this project. |
| final FlutterManifest manifest; |
| |
| /// The manifest of the example sub-project of this project. |
| final FlutterManifest _exampleManifest; |
| |
| /// The set of organization names found in this project as |
| /// part of iOS product bundle identifier, Android application ID, or |
| /// Gradle group ID. |
| Future<Set<String>> get organizationNames async { |
| final List<String> candidates = <String>[ |
| await ios.productBundleIdentifier, |
| android.applicationId, |
| android.group, |
| example.android.applicationId, |
| await example.ios.productBundleIdentifier, |
| ]; |
| return Set<String>.from(candidates |
| .map<String>(_organizationNameFromPackageName) |
| .where((String name) => name != null)); |
| } |
| |
| String _organizationNameFromPackageName(String packageName) { |
| if (packageName != null && 0 <= packageName.lastIndexOf('.')) { |
| return packageName.substring(0, packageName.lastIndexOf('.')); |
| } |
| return null; |
| } |
| |
| /// The iOS sub project of this project. |
| IosProject _ios; |
| IosProject get ios => _ios ??= IosProject.fromFlutter(this); |
| |
| /// The Android sub project of this project. |
| AndroidProject _android; |
| AndroidProject get android => _android ??= AndroidProject._(this); |
| |
| /// The web sub project of this project. |
| WebProject _web; |
| WebProject get web => _web ??= WebProject._(this); |
| |
| /// The MacOS sub project of this project. |
| MacOSProject _macos; |
| MacOSProject get macos => _macos ??= MacOSProject._(this); |
| |
| /// The Linux sub project of this project. |
| LinuxProject _linux; |
| LinuxProject get linux => _linux ??= LinuxProject._(this); |
| |
| /// The Windows sub project of this project. |
| WindowsProject _windows; |
| WindowsProject get windows => _windows ??= WindowsProject._(this); |
| |
| /// The Fuchsia sub project of this project. |
| FuchsiaProject _fuchsia; |
| FuchsiaProject get fuchsia => _fuchsia ??= FuchsiaProject._(this); |
| |
| /// The `pubspec.yaml` file of this project. |
| File get pubspecFile => directory.childFile('pubspec.yaml'); |
| |
| /// The `.packages` file of this project. |
| File get packagesFile => directory.childFile('.packages'); |
| |
| /// The `.flutter-plugins` file of this project. |
| File get flutterPluginsFile => directory.childFile('.flutter-plugins'); |
| |
| /// The `.flutter-plugins-dependencies` file of this project, |
| /// which contains the dependencies each plugin depends on. |
| File get flutterPluginsDependenciesFile => directory.childFile('.flutter-plugins-dependencies'); |
| |
| /// The `.dart-tool` directory of this project. |
| Directory get dartTool => directory.childDirectory('.dart_tool'); |
| |
| /// The directory containing the generated code for this project. |
| Directory get generated => directory |
| .absolute |
| .childDirectory('.dart_tool') |
| .childDirectory('build') |
| .childDirectory('generated') |
| .childDirectory(manifest.appName); |
| |
| /// The example sub-project of this project. |
| FlutterProject get example => FlutterProject( |
| _exampleDirectory(directory), |
| _exampleManifest, |
| FlutterManifest.empty(), |
| ); |
| |
| /// True if this project is a Flutter module project. |
| bool get isModule => manifest.isModule; |
| |
| /// True if the Flutter project is using the AndroidX support library |
| bool get usesAndroidX => manifest.usesAndroidX; |
| |
| /// True if this project has an example application. |
| bool get hasExampleApp => _exampleDirectory(directory).existsSync(); |
| |
| /// The directory that will contain the example if an example exists. |
| static Directory _exampleDirectory(Directory directory) => directory.childDirectory('example'); |
| |
| /// Reads and validates the `pubspec.yaml` file at [path], asynchronously |
| /// returning a [FlutterManifest] representation of the contents. |
| /// |
| /// Completes with an empty [FlutterManifest], if the file does not exist. |
| /// Completes with a ToolExit on validation error. |
| static FlutterManifest _readManifest(String path) { |
| FlutterManifest manifest; |
| try { |
| manifest = FlutterManifest.createFromPath(path); |
| } on YamlException catch (e) { |
| globals.printStatus('Error detected in pubspec.yaml:', emphasis: true); |
| globals.printError('$e'); |
| } |
| if (manifest == null) { |
| throwToolExit('Please correct the pubspec.yaml file at $path'); |
| } |
| return manifest; |
| } |
| |
| /// Generates project files necessary to make Gradle builds work on Android |
| /// and CocoaPods+Xcode work on iOS, for app and module projects only. |
| Future<void> ensureReadyForPlatformSpecificTooling({bool checkProjects = false}) async { |
| if (!directory.existsSync() || hasExampleApp) { |
| return; |
| } |
| refreshPluginsList(this); |
| if ((android.existsSync() && checkProjects) || !checkProjects) { |
| await android.ensureReadyForPlatformSpecificTooling(); |
| } |
| if ((ios.existsSync() && checkProjects) || !checkProjects) { |
| await ios.ensureReadyForPlatformSpecificTooling(); |
| } |
| // TODO(stuartmorgan): Revisit conditions once there is a plan for handling |
| // non-default platform projects. For now, always treat checkProjects as |
| // true for desktop. |
| if (featureFlags.isLinuxEnabled && linux.existsSync()) { |
| await linux.ensureReadyForPlatformSpecificTooling(); |
| } |
| if (featureFlags.isMacOSEnabled && macos.existsSync()) { |
| await macos.ensureReadyForPlatformSpecificTooling(); |
| } |
| if (featureFlags.isWindowsEnabled && windows.existsSync()) { |
| await windows.ensureReadyForPlatformSpecificTooling(); |
| } |
| if (featureFlags.isWebEnabled && web.existsSync()) { |
| await web.ensureReadyForPlatformSpecificTooling(); |
| } |
| await injectPlugins(this, checkProjects: checkProjects); |
| } |
| |
| /// Return the set of builders used by this package. |
| YamlMap get builders { |
| if (!pubspecFile.existsSync()) { |
| return null; |
| } |
| final YamlMap pubspec = loadYaml(pubspecFile.readAsStringSync()) as YamlMap; |
| // If the pubspec file is empty, this will be null. |
| if (pubspec == null) { |
| return null; |
| } |
| return pubspec['builders'] as YamlMap; |
| } |
| |
| /// Whether there are any builders used by this package. |
| bool get hasBuilders { |
| final YamlMap result = builders; |
| return result != null && result.isNotEmpty; |
| } |
| } |
| |
| /// Base class for projects per platform. |
| abstract class FlutterProjectPlatform { |
| |
| /// Plugin's platform config key, e.g., "macos", "ios". |
| String get pluginConfigKey; |
| |
| /// Whether the platform exists in the project. |
| bool existsSync(); |
| } |
| |
| /// Represents an Xcode-based sub-project. |
| /// |
| /// This defines interfaces common to iOS and macOS projects. |
| abstract class XcodeBasedProject { |
| /// The parent of this project. |
| FlutterProject get parent; |
| |
| /// Whether the subproject (either iOS or macOS) exists in the Flutter project. |
| bool existsSync(); |
| |
| /// The Xcode project (.xcodeproj directory) of the host app. |
| Directory get xcodeProject; |
| |
| /// The 'project.pbxproj' file of [xcodeProject]. |
| File get xcodeProjectInfoFile; |
| |
| /// The Xcode workspace (.xcworkspace directory) of the host app. |
| Directory get xcodeWorkspace; |
| |
| /// Contains definitions for FLUTTER_ROOT, LOCAL_ENGINE, and more flags for |
| /// the Xcode build. |
| File get generatedXcodePropertiesFile; |
| |
| /// The Flutter-managed Xcode config file for [mode]. |
| File xcodeConfigFor(String mode); |
| |
| /// The script that exports environment variables needed for Flutter tools. |
| /// Can be run first in a Xcode Script build phase to make FLUTTER_ROOT, |
| /// LOCAL_ENGINE, and other Flutter variables available to any flutter |
| /// tooling (`flutter build`, etc) to convert into flags. |
| File get generatedEnvironmentVariableExportScript; |
| |
| /// The CocoaPods 'Podfile'. |
| File get podfile; |
| |
| /// The CocoaPods 'Podfile.lock'. |
| File get podfileLock; |
| |
| /// The CocoaPods 'Manifest.lock'. |
| File get podManifestLock; |
| |
| /// Directory containing symlinks to pub cache plugins source generated on `pod install`. |
| Directory get symlinks; |
| } |
| |
| /// Represents the iOS sub-project of a Flutter project. |
| /// |
| /// Instances will reflect the contents of the `ios/` sub-folder of |
| /// Flutter applications and the `.ios/` sub-folder of Flutter module projects. |
| class IosProject extends FlutterProjectPlatform implements XcodeBasedProject { |
| IosProject.fromFlutter(this.parent); |
| |
| @override |
| final FlutterProject parent; |
| |
| @override |
| String get pluginConfigKey => IOSPlugin.kConfigKey; |
| |
| static final RegExp _productBundleIdPattern = RegExp(r'''^\s*PRODUCT_BUNDLE_IDENTIFIER\s*=\s*(["']?)(.*?)\1;\s*$'''); |
| static const String _productBundleIdVariable = r'$(PRODUCT_BUNDLE_IDENTIFIER)'; |
| static const String _hostAppBundleName = 'Runner'; |
| |
| Directory get ephemeralDirectory => parent.directory.childDirectory('.ios'); |
| Directory get _editableDirectory => parent.directory.childDirectory('ios'); |
| |
| /// This parent folder of `Runner.xcodeproj`. |
| Directory get hostAppRoot { |
| if (!isModule || _editableDirectory.existsSync()) { |
| return _editableDirectory; |
| } |
| return ephemeralDirectory; |
| } |
| |
| /// The root directory of the iOS wrapping of Flutter and plugins. This is the |
| /// parent of the `Flutter/` folder into which Flutter artifacts are written |
| /// during build. |
| /// |
| /// This is the same as [hostAppRoot] except when the project is |
| /// a Flutter module with an editable host app. |
| Directory get _flutterLibRoot => isModule ? ephemeralDirectory : _editableDirectory; |
| |
| /// The bundle name of the host app, `Runner.app`. |
| String get hostAppBundleName => '$_hostAppBundleName.app'; |
| |
| /// True, if the parent Flutter project is a module project. |
| bool get isModule => parent.isModule; |
| |
| /// Whether the flutter application has an iOS project. |
| bool get exists => hostAppRoot.existsSync(); |
| |
| @override |
| File xcodeConfigFor(String mode) => _flutterLibRoot.childDirectory('Flutter').childFile('$mode.xcconfig'); |
| |
| @override |
| File get generatedEnvironmentVariableExportScript => _flutterLibRoot.childDirectory('Flutter').childFile('flutter_export_environment.sh'); |
| |
| @override |
| File get podfile => hostAppRoot.childFile('Podfile'); |
| |
| @override |
| File get podfileLock => hostAppRoot.childFile('Podfile.lock'); |
| |
| @override |
| File get podManifestLock => hostAppRoot.childDirectory('Pods').childFile('Manifest.lock'); |
| |
| /// The default 'Info.plist' file of the host app. The developer can change this location in Xcode. |
| File get defaultHostInfoPlist => hostAppRoot.childDirectory(_hostAppBundleName).childFile('Info.plist'); |
| |
| @override |
| Directory get symlinks => _flutterLibRoot.childDirectory('.symlinks'); |
| |
| @override |
| Directory get xcodeProject => hostAppRoot.childDirectory('$_hostAppBundleName.xcodeproj'); |
| |
| @override |
| File get xcodeProjectInfoFile => xcodeProject.childFile('project.pbxproj'); |
| |
| @override |
| Directory get xcodeWorkspace => hostAppRoot.childDirectory('$_hostAppBundleName.xcworkspace'); |
| |
| /// Xcode workspace shared data directory for the host app. |
| Directory get xcodeWorkspaceSharedData => xcodeWorkspace.childDirectory('xcshareddata'); |
| |
| /// Xcode workspace shared workspace settings file for the host app. |
| File get xcodeWorkspaceSharedSettings => xcodeWorkspaceSharedData.childFile('WorkspaceSettings.xcsettings'); |
| |
| @override |
| bool existsSync() { |
| return parent.isModule || _editableDirectory.existsSync(); |
| } |
| |
| /// The product bundle identifier of the host app, or null if not set or if |
| /// iOS tooling needed to read it is not installed. |
| Future<String> get productBundleIdentifier async { |
| String fromPlist; |
| final File defaultInfoPlist = defaultHostInfoPlist; |
| // Users can change the location of the Info.plist. |
| // Try parsing the default, first. |
| if (defaultInfoPlist.existsSync()) { |
| try { |
| fromPlist = PlistParser.instance.getValueFromFile( |
| defaultHostInfoPlist.path, |
| PlistParser.kCFBundleIdentifierKey, |
| ); |
| } on FileNotFoundException { |
| // iOS tooling not found; likely not running OSX; let [fromPlist] be null |
| } |
| if (fromPlist != null && !fromPlist.contains('\$')) { |
| // Info.plist has no build variables in product bundle ID. |
| return fromPlist; |
| } |
| } |
| final Map<String, String> allBuildSettings = await buildSettings; |
| if (allBuildSettings != null) { |
| if (fromPlist != null) { |
| // Perform variable substitution using build settings. |
| return xcode.substituteXcodeVariables(fromPlist, allBuildSettings); |
| } |
| return allBuildSettings['PRODUCT_BUNDLE_IDENTIFIER']; |
| } |
| |
| // On non-macOS platforms, parse the first PRODUCT_BUNDLE_IDENTIFIER from |
| // the project file. This can return the wrong bundle identifier if additional |
| // bundles have been added to the project and are found first, like frameworks |
| // or companion watchOS projects. However, on non-macOS platforms this is |
| // only used for display purposes and to regenerate organization names, so |
| // best-effort is probably fine. |
| final String fromPbxproj = _firstMatchInFile(xcodeProjectInfoFile, _productBundleIdPattern)?.group(2); |
| if (fromPbxproj != null && (fromPlist == null || fromPlist == _productBundleIdVariable)) { |
| return fromPbxproj; |
| } |
| |
| return null; |
| } |
| |
| /// The build settings for the host app of this project, as a detached map. |
| /// |
| /// Returns null, if iOS tooling is unavailable. |
| Future<Map<String, String>> get buildSettings async { |
| if (!xcode.xcodeProjectInterpreter.isInstalled) { |
| return null; |
| } |
| Map<String, String> buildSettings = _buildSettings; |
| buildSettings ??= await xcode.xcodeProjectInterpreter.getBuildSettings( |
| xcodeProject.path, |
| _hostAppBundleName, |
| ); |
| if (buildSettings != null && buildSettings.isNotEmpty) { |
| // No timeouts, flakes, or errors. |
| _buildSettings = buildSettings; |
| return buildSettings; |
| } |
| return null; |
| } |
| |
| Map<String, String> _buildSettings; |
| |
| Future<void> ensureReadyForPlatformSpecificTooling() async { |
| _regenerateFromTemplateIfNeeded(); |
| if (!_flutterLibRoot.existsSync()) { |
| return; |
| } |
| await _updateGeneratedXcodeConfigIfNeeded(); |
| } |
| |
| Future<void> _updateGeneratedXcodeConfigIfNeeded() async { |
| if (globals.cache.isOlderThanToolsStamp(generatedXcodePropertiesFile)) { |
| await xcode.updateGeneratedXcodeProperties( |
| project: parent, |
| buildInfo: BuildInfo.debug, |
| targetOverride: bundle.defaultMainPath, |
| ); |
| } |
| } |
| |
| void _regenerateFromTemplateIfNeeded() { |
| if (!isModule) { |
| return; |
| } |
| final bool pubspecChanged = fsUtils.isOlderThanReference( |
| entity: ephemeralDirectory, |
| referenceFile: parent.pubspecFile, |
| ); |
| final bool toolingChanged = globals.cache.isOlderThanToolsStamp(ephemeralDirectory); |
| if (!pubspecChanged && !toolingChanged) { |
| return; |
| } |
| |
| _deleteIfExistsSync(ephemeralDirectory); |
| _overwriteFromTemplate( |
| globals.fs.path.join('module', 'ios', 'library'), |
| ephemeralDirectory, |
| ); |
| // Add ephemeral host app, if a editable host app does not already exist. |
| if (!_editableDirectory.existsSync()) { |
| _overwriteFromTemplate( |
| globals.fs.path.join('module', 'ios', 'host_app_ephemeral'), |
| ephemeralDirectory, |
| ); |
| if (hasPlugins(parent)) { |
| _overwriteFromTemplate( |
| globals.fs.path.join('module', 'ios', 'host_app_ephemeral_cocoapods'), |
| ephemeralDirectory, |
| ); |
| } |
| copyEngineArtifactToProject(BuildMode.debug); |
| } |
| } |
| |
| void copyEngineArtifactToProject(BuildMode mode) { |
| // Copy podspec and framework from engine cache. The actual build mode |
| // doesn't actually matter as it will be overwritten by xcode_backend.sh. |
| // However, cocoapods will run before that script and requires something |
| // to be in this location. |
| final Directory framework = globals.fs.directory( |
| globals.artifacts.getArtifactPath( |
| Artifact.flutterFramework, |
| platform: TargetPlatform.ios, |
| mode: mode, |
| ) |
| ); |
| if (framework.existsSync()) { |
| final Directory engineDest = ephemeralDirectory |
| .childDirectory('Flutter') |
| .childDirectory('engine'); |
| final File podspec = framework.parent.childFile('Flutter.podspec'); |
| fsUtils.copyDirectorySync( |
| framework, |
| engineDest.childDirectory('Flutter.framework'), |
| ); |
| podspec.copySync(engineDest.childFile('Flutter.podspec').path); |
| } |
| } |
| |
| Future<void> makeHostAppEditable() async { |
| assert(isModule); |
| if (_editableDirectory.existsSync()) { |
| throwToolExit('iOS host app is already editable. To start fresh, delete the ios/ folder.'); |
| } |
| _deleteIfExistsSync(ephemeralDirectory); |
| _overwriteFromTemplate( |
| globals.fs.path.join('module', 'ios', 'library'), |
| ephemeralDirectory, |
| ); |
| _overwriteFromTemplate( |
| globals.fs.path.join('module', 'ios', 'host_app_ephemeral'), |
| _editableDirectory, |
| ); |
| _overwriteFromTemplate( |
| globals.fs.path.join('module', 'ios', 'host_app_ephemeral_cocoapods'), |
| _editableDirectory, |
| ); |
| _overwriteFromTemplate( |
| globals.fs.path.join('module', 'ios', 'host_app_editable_cocoapods'), |
| _editableDirectory, |
| ); |
| await _updateGeneratedXcodeConfigIfNeeded(); |
| await injectPlugins(parent); |
| } |
| |
| @override |
| File get generatedXcodePropertiesFile => _flutterLibRoot |
| .childDirectory('Flutter') |
| .childFile('Generated.xcconfig'); |
| |
| Directory get pluginRegistrantHost { |
| return isModule |
| ? _flutterLibRoot |
| .childDirectory('Flutter') |
| .childDirectory('FlutterPluginRegistrant') |
| : hostAppRoot.childDirectory(_hostAppBundleName); |
| } |
| |
| void _overwriteFromTemplate(String path, Directory target) { |
| final Template template = Template.fromName(path); |
| template.render( |
| target, |
| <String, dynamic>{ |
| 'projectName': parent.manifest.appName, |
| 'iosIdentifier': parent.manifest.iosBundleIdentifier, |
| }, |
| printStatusWhenWriting: false, |
| overwriteExisting: true, |
| ); |
| } |
| } |
| |
| /// Represents the Android sub-project of a Flutter project. |
| /// |
| /// Instances will reflect the contents of the `android/` sub-folder of |
| /// Flutter applications and the `.android/` sub-folder of Flutter module projects. |
| class AndroidProject extends FlutterProjectPlatform { |
| AndroidProject._(this.parent); |
| |
| /// The parent of this project. |
| final FlutterProject parent; |
| |
| @override |
| String get pluginConfigKey => AndroidPlugin.kConfigKey; |
| |
| static final RegExp _applicationIdPattern = RegExp('^\\s*applicationId\\s+[\'\"](.*)[\'\"]\\s*\$'); |
| static final RegExp _kotlinPluginPattern = RegExp('^\\s*apply plugin\:\\s+[\'\"]kotlin-android[\'\"]\\s*\$'); |
| static final RegExp _groupPattern = RegExp('^\\s*group\\s+[\'\"](.*)[\'\"]\\s*\$'); |
| |
| /// The Gradle root directory of the Android host app. This is the directory |
| /// containing the `app/` subdirectory and the `settings.gradle` file that |
| /// includes it in the overall Gradle project. |
| Directory get hostAppGradleRoot { |
| if (!isModule || _editableHostAppDirectory.existsSync()) { |
| return _editableHostAppDirectory; |
| } |
| return ephemeralDirectory; |
| } |
| |
| /// The Gradle root directory of the Android wrapping of Flutter and plugins. |
| /// This is the same as [hostAppGradleRoot] except when the project is |
| /// a Flutter module with an editable host app. |
| Directory get _flutterLibGradleRoot => isModule ? ephemeralDirectory : _editableHostAppDirectory; |
| |
| Directory get ephemeralDirectory => parent.directory.childDirectory('.android'); |
| Directory get _editableHostAppDirectory => parent.directory.childDirectory('android'); |
| |
| /// True if the parent Flutter project is a module. |
| bool get isModule => parent.isModule; |
| |
| /// True if the Flutter project is using the AndroidX support library |
| bool get usesAndroidX => parent.usesAndroidX; |
| |
| /// True, if the app project is using Kotlin. |
| bool get isKotlin { |
| final File gradleFile = hostAppGradleRoot.childDirectory('app').childFile('build.gradle'); |
| return _firstMatchInFile(gradleFile, _kotlinPluginPattern) != null; |
| } |
| |
| File get appManifestFile { |
| return isUsingGradle |
| ? globals.fs.file(globals.fs.path.join(hostAppGradleRoot.path, 'app', 'src', 'main', 'AndroidManifest.xml')) |
| : hostAppGradleRoot.childFile('AndroidManifest.xml'); |
| } |
| |
| File get gradleAppOutV1File => gradleAppOutV1Directory.childFile('app-debug.apk'); |
| |
| Directory get gradleAppOutV1Directory { |
| return globals.fs.directory(globals.fs.path.join(hostAppGradleRoot.path, 'app', 'build', 'outputs', 'apk')); |
| } |
| |
| /// Whether the current flutter project has an Android sub-project. |
| @override |
| bool existsSync() { |
| return parent.isModule || _editableHostAppDirectory.existsSync(); |
| } |
| |
| bool get isUsingGradle { |
| return hostAppGradleRoot.childFile('build.gradle').existsSync(); |
| } |
| |
| String get applicationId { |
| final File gradleFile = hostAppGradleRoot.childDirectory('app').childFile('build.gradle'); |
| return _firstMatchInFile(gradleFile, _applicationIdPattern)?.group(1); |
| } |
| |
| String get group { |
| final File gradleFile = hostAppGradleRoot.childFile('build.gradle'); |
| return _firstMatchInFile(gradleFile, _groupPattern)?.group(1); |
| } |
| |
| /// The build directory where the Android artifacts are placed. |
| Directory get buildDirectory { |
| return parent.directory.childDirectory('build'); |
| } |
| |
| Future<void> ensureReadyForPlatformSpecificTooling() async { |
| if (isModule && _shouldRegenerateFromTemplate()) { |
| _regenerateLibrary(); |
| // Add ephemeral host app, if an editable host app does not already exist. |
| if (!_editableHostAppDirectory.existsSync()) { |
| _overwriteFromTemplate(globals.fs.path.join('module', 'android', 'host_app_common'), ephemeralDirectory); |
| _overwriteFromTemplate(globals.fs.path.join('module', 'android', 'host_app_ephemeral'), ephemeralDirectory); |
| } |
| } |
| if (!hostAppGradleRoot.existsSync()) { |
| return; |
| } |
| gradle.updateLocalProperties(project: parent, requireAndroidSdk: false); |
| } |
| |
| bool _shouldRegenerateFromTemplate() { |
| return fsUtils.isOlderThanReference( |
| entity: ephemeralDirectory, |
| referenceFile: parent.pubspecFile, |
| ) || globals.cache.isOlderThanToolsStamp(ephemeralDirectory); |
| } |
| |
| Future<void> makeHostAppEditable() async { |
| assert(isModule); |
| if (_editableHostAppDirectory.existsSync()) { |
| throwToolExit('Android host app is already editable. To start fresh, delete the android/ folder.'); |
| } |
| _regenerateLibrary(); |
| _overwriteFromTemplate(globals.fs.path.join('module', 'android', 'host_app_common'), _editableHostAppDirectory); |
| _overwriteFromTemplate(globals.fs.path.join('module', 'android', 'host_app_editable'), _editableHostAppDirectory); |
| _overwriteFromTemplate(globals.fs.path.join('module', 'android', 'gradle'), _editableHostAppDirectory); |
| gradle.gradleUtils.injectGradleWrapperIfNeeded(_editableHostAppDirectory); |
| gradle.writeLocalProperties(_editableHostAppDirectory.childFile('local.properties')); |
| await injectPlugins(parent); |
| } |
| |
| File get localPropertiesFile => _flutterLibGradleRoot.childFile('local.properties'); |
| |
| Directory get pluginRegistrantHost => _flutterLibGradleRoot.childDirectory(isModule ? 'Flutter' : 'app'); |
| |
| void _regenerateLibrary() { |
| _deleteIfExistsSync(ephemeralDirectory); |
| _overwriteFromTemplate(globals.fs.path.join( |
| 'module', |
| 'android', |
| featureFlags.isAndroidEmbeddingV2Enabled ? 'library_new_embedding' : 'library', |
| ), ephemeralDirectory); |
| _overwriteFromTemplate(globals.fs.path.join('module', 'android', 'gradle'), ephemeralDirectory); |
| gradle.gradleUtils.injectGradleWrapperIfNeeded(ephemeralDirectory); |
| } |
| |
| void _overwriteFromTemplate(String path, Directory target) { |
| final Template template = Template.fromName(path); |
| template.render( |
| target, |
| <String, dynamic>{ |
| 'projectName': parent.manifest.appName, |
| 'androidIdentifier': parent.manifest.androidPackage, |
| 'androidX': usesAndroidX, |
| 'useAndroidEmbeddingV2': featureFlags.isAndroidEmbeddingV2Enabled, |
| }, |
| printStatusWhenWriting: false, |
| overwriteExisting: true, |
| ); |
| } |
| |
| AndroidEmbeddingVersion getEmbeddingVersion() { |
| if (isModule) { |
| // A module type's Android project is used in add-to-app scenarios and |
| // only supports the V2 embedding. |
| return AndroidEmbeddingVersion.v2; |
| } |
| if (appManifestFile == null || !appManifestFile.existsSync()) { |
| return AndroidEmbeddingVersion.v1; |
| } |
| xml.XmlDocument document; |
| try { |
| document = xml.parse(appManifestFile.readAsStringSync()); |
| } on xml.XmlParserException { |
| throwToolExit('Error parsing $appManifestFile ' |
| 'Please ensure that the android manifest is a valid XML document and try again.'); |
| } on FileSystemException { |
| throwToolExit('Error reading $appManifestFile even though it exists. ' |
| 'Please ensure that you have read permission to this file and try again.'); |
| } |
| for (final xml.XmlElement metaData in document.findAllElements('meta-data')) { |
| final String name = metaData.getAttribute('android:name'); |
| if (name == 'flutterEmbedding') { |
| final String embeddingVersionString = metaData.getAttribute('android:value'); |
| if (embeddingVersionString == '1') { |
| return AndroidEmbeddingVersion.v1; |
| } |
| if (embeddingVersionString == '2') { |
| return AndroidEmbeddingVersion.v2; |
| } |
| } |
| } |
| return AndroidEmbeddingVersion.v1; |
| } |
| } |
| |
| /// Iteration of the embedding Java API in the engine used by the Android project. |
| enum AndroidEmbeddingVersion { |
| /// V1 APIs based on io.flutter.app.FlutterActivity. |
| v1, |
| /// V2 APIs based on io.flutter.embedding.android.FlutterActivity. |
| v2, |
| } |
| |
| /// Represents the web sub-project of a Flutter project. |
| class WebProject extends FlutterProjectPlatform { |
| WebProject._(this.parent); |
| |
| final FlutterProject parent; |
| |
| @override |
| String get pluginConfigKey => WebPlugin.kConfigKey; |
| |
| /// Whether this flutter project has a web sub-project. |
| @override |
| bool existsSync() { |
| return parent.directory.childDirectory('web').existsSync() |
| && indexFile.existsSync(); |
| } |
| |
| /// The 'lib' directory for the application. |
| Directory get libDirectory => parent.directory.childDirectory('lib'); |
| |
| /// The directory containing additional files for the application. |
| Directory get directory => parent.directory.childDirectory('web'); |
| |
| /// The html file used to host the flutter web application. |
| File get indexFile => parent.directory |
| .childDirectory('web') |
| .childFile('index.html'); |
| |
| Future<void> ensureReadyForPlatformSpecificTooling() async {} |
| } |
| |
| /// Deletes [directory] with all content. |
| void _deleteIfExistsSync(Directory directory) { |
| if (directory.existsSync()) { |
| directory.deleteSync(recursive: true); |
| } |
| } |
| |
| |
| /// Returns the first line-based match for [regExp] in [file]. |
| /// |
| /// Assumes UTF8 encoding. |
| Match _firstMatchInFile(File file, RegExp regExp) { |
| if (!file.existsSync()) { |
| return null; |
| } |
| for (final String line in file.readAsLinesSync()) { |
| final Match match = regExp.firstMatch(line); |
| if (match != null) { |
| return match; |
| } |
| } |
| return null; |
| } |
| |
| /// The macOS sub project. |
| class MacOSProject extends FlutterProjectPlatform implements XcodeBasedProject { |
| MacOSProject._(this.parent); |
| |
| @override |
| final FlutterProject parent; |
| |
| @override |
| String get pluginConfigKey => MacOSPlugin.kConfigKey; |
| |
| static const String _hostAppBundleName = 'Runner'; |
| |
| @override |
| bool existsSync() => _macOSDirectory.existsSync(); |
| |
| Directory get _macOSDirectory => parent.directory.childDirectory('macos'); |
| |
| /// The directory in the project that is managed by Flutter. As much as |
| /// possible, files that are edited by Flutter tooling after initial project |
| /// creation should live here. |
| Directory get managedDirectory => _macOSDirectory.childDirectory('Flutter'); |
| |
| /// The subdirectory of [managedDirectory] that contains files that are |
| /// generated on the fly. All generated files that are not intended to be |
| /// checked in should live here. |
| Directory get ephemeralDirectory => managedDirectory.childDirectory('ephemeral'); |
| |
| /// The xcfilelist used to track the inputs for the Flutter script phase in |
| /// the Xcode build. |
| File get inputFileList => ephemeralDirectory.childFile('FlutterInputs.xcfilelist'); |
| |
| /// The xcfilelist used to track the outputs for the Flutter script phase in |
| /// the Xcode build. |
| File get outputFileList => ephemeralDirectory.childFile('FlutterOutputs.xcfilelist'); |
| |
| @override |
| File get generatedXcodePropertiesFile => ephemeralDirectory.childFile('Flutter-Generated.xcconfig'); |
| |
| @override |
| File xcodeConfigFor(String mode) => managedDirectory.childFile('Flutter-$mode.xcconfig'); |
| |
| @override |
| File get generatedEnvironmentVariableExportScript => ephemeralDirectory.childFile('flutter_export_environment.sh'); |
| |
| @override |
| File get podfile => _macOSDirectory.childFile('Podfile'); |
| |
| @override |
| File get podfileLock => _macOSDirectory.childFile('Podfile.lock'); |
| |
| @override |
| File get podManifestLock => _macOSDirectory.childDirectory('Pods').childFile('Manifest.lock'); |
| |
| @override |
| Directory get xcodeProject => _macOSDirectory.childDirectory('$_hostAppBundleName.xcodeproj'); |
| |
| @override |
| File get xcodeProjectInfoFile => xcodeProject.childFile('project.pbxproj'); |
| |
| @override |
| Directory get xcodeWorkspace => _macOSDirectory.childDirectory('$_hostAppBundleName.xcworkspace'); |
| |
| @override |
| Directory get symlinks => ephemeralDirectory.childDirectory('.symlinks'); |
| |
| /// The file where the Xcode build will write the name of the built app. |
| /// |
| /// Ideally this will be replaced in the future with inspection of the Runner |
| /// scheme's target. |
| File get nameFile => ephemeralDirectory.childFile('.app_filename'); |
| |
| Future<void> ensureReadyForPlatformSpecificTooling() async { |
| // TODO(stuartmorgan): Add create-from-template logic here. |
| await _updateGeneratedXcodeConfigIfNeeded(); |
| } |
| |
| Future<void> _updateGeneratedXcodeConfigIfNeeded() async { |
| if (globals.cache.isOlderThanToolsStamp(generatedXcodePropertiesFile)) { |
| await xcode.updateGeneratedXcodeProperties( |
| project: parent, |
| buildInfo: BuildInfo.debug, |
| useMacOSConfig: true, |
| setSymroot: false, |
| ); |
| } |
| } |
| } |
| |
| /// The Windows sub project |
| class WindowsProject extends FlutterProjectPlatform { |
| WindowsProject._(this.project); |
| |
| final FlutterProject project; |
| |
| @override |
| String get pluginConfigKey => WindowsPlugin.kConfigKey; |
| |
| @override |
| bool existsSync() => _editableDirectory.existsSync(); |
| |
| Directory get _editableDirectory => project.directory.childDirectory('windows'); |
| |
| /// The directory in the project that is managed by Flutter. As much as |
| /// possible, files that are edited by Flutter tooling after initial project |
| /// creation should live here. |
| Directory get managedDirectory => _editableDirectory.childDirectory('flutter'); |
| |
| /// The subdirectory of [managedDirectory] that contains files that are |
| /// generated on the fly. All generated files that are not intended to be |
| /// checked in should live here. |
| Directory get ephemeralDirectory => managedDirectory.childDirectory('ephemeral'); |
| |
| /// Contains definitions for FLUTTER_ROOT, LOCAL_ENGINE, and more flags for |
| /// the build. |
| File get generatedPropertySheetFile => ephemeralDirectory.childFile('Generated.props'); |
| |
| // The MSBuild project file. |
| File get vcprojFile => _editableDirectory.childFile('Runner.vcxproj'); |
| |
| // The MSBuild solution file. |
| File get solutionFile => _editableDirectory.childFile('Runner.sln'); |
| |
| /// The file where the VS build will write the name of the built app. |
| /// |
| /// Ideally this will be replaced in the future with inspection of the project. |
| File get nameFile => ephemeralDirectory.childFile('exe_filename'); |
| |
| Future<void> ensureReadyForPlatformSpecificTooling() async {} |
| } |
| |
| /// The Linux sub project. |
| class LinuxProject extends FlutterProjectPlatform { |
| LinuxProject._(this.project); |
| |
| final FlutterProject project; |
| |
| @override |
| String get pluginConfigKey => LinuxPlugin.kConfigKey; |
| |
| Directory get _editableDirectory => project.directory.childDirectory('linux'); |
| |
| /// The directory in the project that is managed by Flutter. As much as |
| /// possible, files that are edited by Flutter tooling after initial project |
| /// creation should live here. |
| Directory get managedDirectory => _editableDirectory.childDirectory('flutter'); |
| |
| /// The subdirectory of [managedDirectory] that contains files that are |
| /// generated on the fly. All generated files that are not intended to be |
| /// checked in should live here. |
| Directory get ephemeralDirectory => managedDirectory.childDirectory('ephemeral'); |
| |
| @override |
| bool existsSync() => _editableDirectory.existsSync(); |
| |
| /// The Linux project makefile. |
| File get makeFile => _editableDirectory.childFile('Makefile'); |
| |
| /// Contains definitions for FLUTTER_ROOT, LOCAL_ENGINE, and more flags for |
| /// the build. |
| File get generatedMakeConfigFile => ephemeralDirectory.childFile('generated_config.mk'); |
| |
| Future<void> ensureReadyForPlatformSpecificTooling() async {} |
| } |
| |
| /// The Fuchsia sub project |
| class FuchsiaProject { |
| FuchsiaProject._(this.project); |
| |
| final FlutterProject project; |
| |
| Directory _editableHostAppDirectory; |
| Directory get editableHostAppDirectory => |
| _editableHostAppDirectory ??= project.directory.childDirectory('fuchsia'); |
| |
| bool existsSync() => editableHostAppDirectory.existsSync(); |
| |
| Directory _meta; |
| Directory get meta => |
| _meta ??= editableHostAppDirectory.childDirectory('meta'); |
| } |