blob: 7a277b65077f75910f9635ac7d49f6331e61e589 [file] [log] [blame]
// 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 'package:meta/meta.dart';
import 'package:process/process.dart';
import '../application_package.dart';
import '../base/common.dart';
import '../base/file_system.dart';
import '../base/io.dart';
import '../base/logger.dart';
import '../base/os.dart';
import '../base/platform.dart';
import '../base/version.dart';
import '../build_info.dart';
import '../device.dart';
import '../device_port_forwarder.dart';
import '../features.dart';
import '../project.dart';
import 'chrome.dart';
class WebApplicationPackage extends ApplicationPackage {
WebApplicationPackage(this.flutterProject) : super(id: flutterProject.manifest.appName);
final FlutterProject flutterProject;
@override
String get name => flutterProject.manifest.appName;
/// The location of the web source assets.
Directory get webSourcePath => flutterProject.directory.childDirectory('web');
}
/// A web device that supports a chromium browser.
abstract class ChromiumDevice extends Device {
ChromiumDevice({
required String name,
required this.chromeLauncher,
required FileSystem fileSystem,
required Logger logger,
}) : _fileSystem = fileSystem,
_logger = logger,
super(
name,
category: Category.web,
platformType: PlatformType.web,
ephemeral: false,
);
final ChromiumLauncher chromeLauncher;
final FileSystem _fileSystem;
final Logger _logger;
/// The active chrome instance.
Chromium? _chrome;
// This device does not actually support hot reload, but the current implementation of the resident runner
// requires both supportsHotReload and supportsHotRestart to be true in order to allow hot restart.
@override
bool get supportsHotReload => true;
@override
bool get supportsHotRestart => true;
@override
bool get supportsStartPaused => true;
@override
bool get supportsFlutterExit => false;
@override
bool get supportsScreenshot => false;
@override
bool supportsRuntimeMode(BuildMode buildMode) => buildMode != BuildMode.jitRelease;
@override
void clearLogs() { }
DeviceLogReader? _logReader;
@override
DeviceLogReader getLogReader({
ApplicationPackage? app,
bool includePastLogs = false,
}) {
return _logReader ??= NoOpDeviceLogReader(app?.name);
}
@override
Future<bool> installApp(
ApplicationPackage app, {
String? userIdentifier,
}) async => true;
@override
Future<bool> isAppInstalled(
ApplicationPackage app, {
String? userIdentifier,
}) async => true;
@override
Future<bool> isLatestBuildInstalled(ApplicationPackage app) async => true;
@override
Future<bool> get isLocalEmulator async => false;
@override
Future<String?> get emulatorId async => null;
@override
bool isSupported() => chromeLauncher.canFindExecutable();
@override
DevicePortForwarder? get portForwarder => const NoOpDevicePortForwarder();
@override
Future<LaunchResult> startApp(
covariant WebApplicationPackage package, {
String? mainPath,
String? route,
required DebuggingOptions debuggingOptions,
Map<String, Object?> platformArgs = const <String, Object?>{},
bool prebuiltApplication = false,
bool ipv6 = false,
String? userIdentifier,
}) async {
// See [ResidentWebRunner.run] in flutter_tools/lib/src/resident_web_runner.dart
// for the web initialization and server logic.
String url;
if (debuggingOptions.webLaunchUrl != null) {
final RegExp pattern = RegExp(r'^((http)?:\/\/)[^\s]+');
if (pattern.hasMatch(debuggingOptions.webLaunchUrl!)) {
url = debuggingOptions.webLaunchUrl!;
} else {
throwToolExit('"${debuggingOptions.webLaunchUrl}" is not a vaild HTTP URL.');
}
} else {
url = platformArgs['uri']! as String;
}
final bool launchChrome = platformArgs['no-launch-chrome'] != true;
if (launchChrome) {
_chrome = await chromeLauncher.launch(
url,
cacheDir: _fileSystem.currentDirectory
.childDirectory('.dart_tool')
.childDirectory('chrome-device'),
headless: debuggingOptions.webRunHeadless,
debugPort: debuggingOptions.webBrowserDebugPort,
);
}
_logger.sendEvent('app.webLaunchUrl', <String, Object>{'url': url, 'launched': launchChrome});
return LaunchResult.succeeded(observatoryUri: url != null ? Uri.parse(url): null);
}
@override
Future<bool> stopApp(
ApplicationPackage app, {
String? userIdentifier,
}) async {
await _chrome?.close();
return true;
}
@override
Future<TargetPlatform> get targetPlatform async => TargetPlatform.web_javascript;
@override
Future<bool> uninstallApp(
ApplicationPackage app, {
String? userIdentifier,
}) async => true;
@override
bool isSupportedForProject(FlutterProject flutterProject) {
return flutterProject.web.existsSync();
}
@override
Future<void> dispose() async {
_logReader?.dispose();
await portForwarder?.dispose();
}
}
/// The Google Chrome browser based on Chromium.
class GoogleChromeDevice extends ChromiumDevice {
GoogleChromeDevice({
required Platform platform,
required ProcessManager processManager,
required ChromiumLauncher chromiumLauncher,
required Logger logger,
required FileSystem fileSystem,
}) : _platform = platform,
_processManager = processManager,
super(
name: 'chrome',
chromeLauncher: chromiumLauncher,
logger: logger,
fileSystem: fileSystem,
);
final Platform _platform;
final ProcessManager _processManager;
@override
String get name => 'Chrome';
@override
late final Future<String> sdkNameAndVersion = _computeSdkNameAndVersion();
Future<String> _computeSdkNameAndVersion() async {
if (!isSupported()) {
return 'unknown';
}
// See https://bugs.chromium.org/p/chromium/issues/detail?id=158372
String version = 'unknown';
if (_platform.isWindows) {
if (_processManager.canRun('reg')) {
final ProcessResult result = await _processManager.run(<String>[
r'reg', 'query', r'HKEY_CURRENT_USER\Software\Google\Chrome\BLBeacon', '/v', 'version',
]);
if (result.exitCode == 0) {
final List<String> parts = (result.stdout as String).split(RegExp(r'\s+'));
if (parts.length > 2) {
version = 'Google Chrome ${parts[parts.length - 2]}';
}
}
}
} else {
final String chrome = chromeLauncher.findExecutable();
final ProcessResult result = await _processManager.run(<String>[
chrome,
'--version',
]);
if (result.exitCode == 0) {
version = result.stdout as String;
}
}
return version.trim();
}
}
/// The Microsoft Edge browser based on Chromium.
class MicrosoftEdgeDevice extends ChromiumDevice {
MicrosoftEdgeDevice({
required ChromiumLauncher chromiumLauncher,
required Logger logger,
required FileSystem fileSystem,
required ProcessManager processManager,
}) : _processManager = processManager,
super(
name: 'edge',
chromeLauncher: chromiumLauncher,
logger: logger,
fileSystem: fileSystem,
);
final ProcessManager _processManager;
// The first version of Edge with chromium support.
static const int _kFirstChromiumEdgeMajorVersion = 79;
@override
String get name => 'Edge';
Future<bool> _meetsVersionConstraint() async {
final String rawVersion = (await sdkNameAndVersion).replaceFirst('Microsoft Edge ', '');
final Version? version = Version.parse(rawVersion);
if (version == null) {
return false;
}
return version.major >= _kFirstChromiumEdgeMajorVersion;
}
@override
late final Future<String> sdkNameAndVersion = _getSdkNameAndVersion();
Future<String> _getSdkNameAndVersion() async {
if (_processManager.canRun('reg')) {
final ProcessResult result = await _processManager.run(<String>[
r'reg', 'query', r'HKEY_CURRENT_USER\Software\Microsoft\Edge\BLBeacon', '/v', 'version',
]);
if (result.exitCode == 0) {
final List<String> parts = (result.stdout as String).split(RegExp(r'\s+'));
if (parts.length > 2) {
return 'Microsoft Edge ${parts[parts.length - 2]}';
}
}
}
// Return a non-null string so that the tool can validate the version
// does not meet the constraint above in _meetsVersionConstraint.
return '';
}
}
class WebDevices extends PollingDeviceDiscovery {
WebDevices({
required FileSystem fileSystem,
required Logger logger,
required Platform platform,
required ProcessManager processManager,
required FeatureFlags featureFlags,
}) : _featureFlags = featureFlags,
_webServerDevice = WebServerDevice(
logger: logger,
),
super('Chrome') {
final OperatingSystemUtils operatingSystemUtils = OperatingSystemUtils(
fileSystem: fileSystem,
platform: platform,
logger: logger,
processManager: processManager,
);
_chromeDevice = GoogleChromeDevice(
fileSystem: fileSystem,
logger: logger,
platform: platform,
processManager: processManager,
chromiumLauncher: ChromiumLauncher(
browserFinder: findChromeExecutable,
fileSystem: fileSystem,
platform: platform,
processManager: processManager,
operatingSystemUtils: operatingSystemUtils,
logger: logger,
),
);
if (platform.isWindows) {
_edgeDevice = MicrosoftEdgeDevice(
chromiumLauncher: ChromiumLauncher(
browserFinder: findEdgeExecutable,
fileSystem: fileSystem,
platform: platform,
processManager: processManager,
operatingSystemUtils: operatingSystemUtils,
logger: logger,
),
processManager: processManager,
logger: logger,
fileSystem: fileSystem,
);
}
}
late final GoogleChromeDevice _chromeDevice;
final WebServerDevice _webServerDevice;
MicrosoftEdgeDevice? _edgeDevice;
final FeatureFlags _featureFlags;
@override
bool get canListAnything => featureFlags.isWebEnabled;
@override
Future<List<Device>> pollingGetDevices({ Duration? timeout }) async {
if (!_featureFlags.isWebEnabled) {
return <Device>[];
}
final MicrosoftEdgeDevice? edgeDevice = _edgeDevice;
return <Device>[
if (WebServerDevice.showWebServerDevice)
_webServerDevice,
if (_chromeDevice.isSupported())
_chromeDevice,
if (edgeDevice != null && await edgeDevice._meetsVersionConstraint())
edgeDevice,
];
}
@override
bool get supportsPlatform => _featureFlags.isWebEnabled;
@override
List<String> get wellKnownIds => const <String>['chrome', 'web-server', 'edge'];
}
@visibleForTesting
String parseVersionForWindows(String input) {
return input.split(RegExp(r'\w')).last;
}
/// A special device type to allow serving for arbitrary browsers.
class WebServerDevice extends Device {
WebServerDevice({
required Logger logger,
}) : _logger = logger,
super(
'web-server',
platformType: PlatformType.web,
category: Category.web,
ephemeral: false,
);
static const String kWebServerDeviceId = 'web-server';
static bool showWebServerDevice = false;
final Logger _logger;
@override
void clearLogs() { }
@override
Future<String?> get emulatorId async => null;
DeviceLogReader? _logReader;
@override
DeviceLogReader getLogReader({
ApplicationPackage? app,
bool includePastLogs = false,
}) {
return _logReader ??= NoOpDeviceLogReader(app?.name);
}
@override
Future<bool> installApp(
ApplicationPackage app, {
String? userIdentifier,
}) async => true;
@override
Future<bool> isAppInstalled(
ApplicationPackage app, {
String? userIdentifier,
}) async => true;
@override
Future<bool> isLatestBuildInstalled(ApplicationPackage app) async => true;
@override
bool get supportsFlutterExit => false;
@override
bool supportsRuntimeMode(BuildMode buildMode) => buildMode != BuildMode.jitRelease;
@override
Future<bool> get isLocalEmulator async => false;
@override
bool isSupported() => true;
@override
bool isSupportedForProject(FlutterProject flutterProject) {
return flutterProject.web.existsSync();
}
@override
String get name => 'Web Server';
@override
DevicePortForwarder? get portForwarder => const NoOpDevicePortForwarder();
@override
Future<String> get sdkNameAndVersion async => 'Flutter Tools';
@override
Future<LaunchResult> startApp(ApplicationPackage package, {
String? mainPath,
String? route,
required DebuggingOptions debuggingOptions,
Map<String, Object?> platformArgs = const <String, Object?>{},
bool prebuiltApplication = false,
bool ipv6 = false,
String? userIdentifier,
}) async {
final String? url = platformArgs['uri'] as String?;
if (debuggingOptions.startPaused) {
_logger.printStatus('Waiting for connection from Dart debug extension at $url', emphasis: true);
} else {
_logger.printStatus('$mainPath is being served at $url', emphasis: true);
}
_logger.printStatus(
'The web-server device requires the Dart Debug Chrome extension for debugging. '
'Consider using the Chrome or Edge devices for an improved development workflow.'
);
_logger.sendEvent('app.webLaunchUrl', <String, Object?>{'url': url, 'launched': false});
return LaunchResult.succeeded(observatoryUri: url != null ? Uri.parse(url): null);
}
@override
Future<bool> stopApp(
ApplicationPackage app, {
String? userIdentifier,
}) async {
return true;
}
@override
Future<TargetPlatform> get targetPlatform async => TargetPlatform.web_javascript;
@override
Future<bool> uninstallApp(
ApplicationPackage app, {
String? userIdentifier,
}) async {
return true;
}
@override
Future<void> dispose() async {
_logReader?.dispose();
await portForwarder?.dispose();
}
}