| // 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:multicast_dns/multicast_dns.dart'; | |
| import 'package:unified_analytics/unified_analytics.dart'; | |
| import 'base/common.dart'; | |
| import 'base/context.dart'; | |
| import 'base/io.dart'; | |
| import 'base/logger.dart'; | |
| import 'build_info.dart'; | |
| import 'convert.dart'; | |
| import 'device.dart'; | |
| import 'globals.dart' as globals; | |
| String _missingLocalNetworkPermissionsInstructions(String err) => | |
| ''' | |
| Flutter could not access the local network. | |
| Please ensure your IDE or terminal app has permission to access devices on the local network. This allows Flutter to connect to the Dart VM. | |
| You can grant this permission in System Settings > Privacy & Security > Local Network. | |
| $err | |
| '''; | |
| /// A wrapper around [MDnsClient] to find a Dart VM Service instance. | |
| class MDnsVmServiceDiscovery { | |
| /// Creates a new [MDnsVmServiceDiscovery] object. | |
| /// | |
| /// The [_client] parameter will be defaulted to a new [MDnsClient] if null. | |
| MDnsVmServiceDiscovery({ | |
| MDnsClient? mdnsClient, | |
| MDnsClient? preliminaryMDnsClient, | |
| required Logger logger, | |
| required Analytics analytics, | |
| }) : _client = mdnsClient ?? MDnsClient(), | |
| _preliminaryClient = preliminaryMDnsClient, | |
| _logger = logger, | |
| _analytics = analytics; | |
| final MDnsClient _client; | |
| // Used when discovering VM services with `queryForAttach` to do a preliminary | |
| // check for already running services so that results are not cached in _client. | |
| final MDnsClient? _preliminaryClient; | |
| final Logger _logger; | |
| final Analytics _analytics; | |
| @visibleForTesting | |
| static const dartVmServiceName = '_dartVmService._tcp.local'; | |
| static MDnsVmServiceDiscovery? get instance => context.get<MDnsVmServiceDiscovery>(); | |
| /// Executes an mDNS query for Dart VM Services. | |
| /// Checks for services that have already been launched. | |
| /// If none are found, it will listen for new services to become active | |
| /// and return the first it finds that match the parameters. | |
| /// | |
| /// The [applicationId] parameter may be used to specify which application | |
| /// to find. For Android, it refers to the package name; on iOS, it refers to | |
| /// the bundle ID. | |
| /// | |
| /// The [deviceVmservicePort] parameter may be used to specify which port | |
| /// to find. | |
| /// | |
| /// The [useDeviceIPAsHost] parameter flags whether to get the device IP | |
| /// and the [ipv6] parameter flags whether to get an iPv6 address | |
| /// (otherwise it will get iPv4). | |
| /// | |
| /// The [timeout] parameter determines how long to continue to wait for | |
| /// services to become active. | |
| /// | |
| /// If [applicationId] is not null, this method will find the port and authentication code | |
| /// of the Dart VM Service for that application. If it cannot find a service matching | |
| /// that application identifier after the [timeout], it will call [throwToolExit]. | |
| /// | |
| /// If [applicationId] is null and there are multiple Dart VM Services available, | |
| /// the user will be prompted with a list of available services with the respective | |
| /// app-id and device-vmservice-port to use and asked to select one. | |
| /// | |
| /// If it is null and there is only one available or it's the first found instance | |
| /// of Dart VM Service, it will return that instance's information regardless of | |
| /// what application the service instance is for. | |
| @visibleForTesting | |
| Future<MDnsVmServiceDiscoveryResult?> queryForAttach({ | |
| String? applicationId, | |
| int? deviceVmservicePort, | |
| bool ipv6 = false, | |
| bool useDeviceIPAsHost = false, | |
| Duration timeout = const Duration(minutes: 10), | |
| bool throwOnMissingLocalNetworkPermissionsError = true, | |
| }) async { | |
| // Poll for 5 seconds to see if there are already services running. | |
| // Use a new instance of MDnsClient so results don't get cached in _client. | |
| // If no results are found, poll for a longer duration to wait for connections. | |
| // If more than 1 result is found, throw an error since it can't be determined which to pick. | |
| // If only one is found, return it. | |
| final List<MDnsVmServiceDiscoveryResult> results = await _pollingVmService( | |
| _preliminaryClient ?? MDnsClient(), | |
| applicationId: applicationId, | |
| deviceVmServicePort: deviceVmservicePort, | |
| ipv6: ipv6, | |
| useDeviceIPAsHost: useDeviceIPAsHost, | |
| timeout: const Duration(seconds: 5), | |
| throwOnMissingLocalNetworkPermissionsError: throwOnMissingLocalNetworkPermissionsError, | |
| ); | |
| if (results.isEmpty) { | |
| return firstMatchingVmService( | |
| _client, | |
| applicationId: applicationId, | |
| deviceVmservicePort: deviceVmservicePort, | |
| ipv6: ipv6, | |
| useDeviceIPAsHost: useDeviceIPAsHost, | |
| timeout: timeout, | |
| ); | |
| } else if (results.length > 1) { | |
| final buffer = StringBuffer(); | |
| buffer.writeln('There are multiple Dart VM Services available.'); | |
| buffer.writeln( | |
| 'Rerun this command with one of the following passed in as the app-id and device-vmservice-port:', | |
| ); | |
| buffer.writeln(); | |
| for (final result in results) { | |
| buffer.writeln( | |
| ' flutter attach --app-id "${result.domainName.replaceAll('.$dartVmServiceName', '')}" --device-vmservice-port ${result.port}', | |
| ); | |
| } | |
| throwToolExit(buffer.toString()); | |
| } | |
| return results.first; | |
| } | |
| /// Executes an mDNS query for Dart VM Services. | |
| /// Listens for new services to become active and returns the first it finds that | |
| /// match the parameters. | |
| /// | |
| /// The [applicationId] parameter must be set to specify which application | |
| /// to find. For Android, it refers to the package name; on iOS, it refers to | |
| /// the bundle ID. | |
| /// | |
| /// The [deviceVmservicePort] parameter must be set to specify which port | |
| /// to find. | |
| /// | |
| /// [applicationId] and either [deviceVmservicePort] or [deviceName] are | |
| /// required for launch so that if multiple flutter apps are running on | |
| /// different devices, it will only match with the device running the desired app. | |
| /// | |
| /// The [useDeviceIPAsHost] parameter flags whether to get the device IP | |
| /// and the [ipv6] parameter flags whether to get an iPv6 address | |
| /// (otherwise it will get iPv4). | |
| /// | |
| /// The [timeout] parameter determines how long to continue to wait for | |
| /// services to become active. | |
| /// | |
| /// If a Dart VM Service matching the [applicationId] and | |
| /// [deviceVmservicePort]/[deviceName] cannot be found before the [timeout] | |
| /// is reached, it will call [throwToolExit]. | |
| @visibleForTesting | |
| Future<MDnsVmServiceDiscoveryResult?> queryForLaunch({ | |
| required String applicationId, | |
| int? deviceVmservicePort, | |
| String? deviceName, | |
| bool ipv6 = false, | |
| bool useDeviceIPAsHost = false, | |
| Duration timeout = const Duration(minutes: 10), | |
| bool throwOnMissingLocalNetworkPermissionsError = true, | |
| }) async { | |
| // Either the device port or the device name must be provided. | |
| assert(deviceVmservicePort != null || deviceName != null); | |
| // Query for a specific application matching on either device port or device name. | |
| return firstMatchingVmService( | |
| _client, | |
| applicationId: applicationId, | |
| deviceVmservicePort: deviceVmservicePort, | |
| deviceName: deviceName, | |
| ipv6: ipv6, | |
| useDeviceIPAsHost: useDeviceIPAsHost, | |
| timeout: timeout, | |
| throwOnMissingLocalNetworkPermissionsError: throwOnMissingLocalNetworkPermissionsError, | |
| ); | |
| } | |
| /// Polls for Dart VM Services and returns the first it finds that match | |
| /// the [applicationId]/[deviceVmservicePort] (if applicable). | |
| /// Returns null if no results are found. | |
| @visibleForTesting | |
| Future<MDnsVmServiceDiscoveryResult?> firstMatchingVmService( | |
| MDnsClient client, { | |
| String? applicationId, | |
| int? deviceVmservicePort, | |
| String? deviceName, | |
| bool ipv6 = false, | |
| bool useDeviceIPAsHost = false, | |
| Duration timeout = const Duration(minutes: 10), | |
| bool throwOnMissingLocalNetworkPermissionsError = true, | |
| }) async { | |
| final List<MDnsVmServiceDiscoveryResult> results = await _pollingVmService( | |
| client, | |
| applicationId: applicationId, | |
| deviceVmServicePort: deviceVmservicePort, | |
| deviceName: deviceName, | |
| ipv6: ipv6, | |
| useDeviceIPAsHost: useDeviceIPAsHost, | |
| timeout: timeout, | |
| quitOnFind: true, | |
| throwOnMissingLocalNetworkPermissionsError: throwOnMissingLocalNetworkPermissionsError, | |
| ); | |
| if (results.isEmpty) { | |
| return null; | |
| } | |
| return results.first; | |
| } | |
| Future<List<MDnsVmServiceDiscoveryResult>> _pollingVmService( | |
| MDnsClient client, { | |
| String? applicationId, | |
| int? deviceVmServicePort, | |
| String? deviceName, | |
| bool ipv6 = false, | |
| bool useDeviceIPAsHost = false, | |
| required Duration timeout, | |
| bool quitOnFind = false, | |
| bool throwOnMissingLocalNetworkPermissionsError = true, | |
| }) async { | |
| // macOS blocks mDNS unless the app has Local Network permissions. | |
| // Since the mDNS client does not handle errors from the socket's stream, | |
| // socket exceptions are routed to the current zone. Create an error zone to | |
| // catch the socket exception. | |
| // See: https://github.com/flutter/flutter/issues/150131 | |
| final completer = Completer<List<MDnsVmServiceDiscoveryResult>>(); | |
| unawaited( | |
| runZonedGuarded( | |
| () async { | |
| final List<MDnsVmServiceDiscoveryResult> results = await _doPollingVmService( | |
| client, | |
| applicationId: applicationId, | |
| deviceVmServicePort: deviceVmServicePort, | |
| deviceName: deviceName, | |
| ipv6: ipv6, | |
| useDeviceIPAsHost: useDeviceIPAsHost, | |
| timeout: timeout, | |
| quitOnFind: quitOnFind, | |
| ); | |
| if (!completer.isCompleted) { | |
| completer.complete(results); | |
| } | |
| }, | |
| (Object error, StackTrace stackTrace) { | |
| if (!completer.isCompleted) { | |
| completer.completeError(error, stackTrace); | |
| } | |
| }, | |
| ), | |
| ); | |
| try { | |
| return await completer.future; | |
| } on SocketException catch (e, stackTrace) { | |
| if (!globals.platform.isMacOS) { | |
| rethrow; | |
| } | |
| _logger.printTrace(stackTrace.toString()); | |
| if (throwOnMissingLocalNetworkPermissionsError) { | |
| throwToolExit(_missingLocalNetworkPermissionsInstructions(e.toString())); | |
| } else { | |
| _logger.printError(_missingLocalNetworkPermissionsInstructions(e.toString())); | |
| return <MDnsVmServiceDiscoveryResult>[]; | |
| } | |
| } | |
| } | |
| Future<List<MDnsVmServiceDiscoveryResult>> _doPollingVmService( | |
| MDnsClient client, { | |
| String? applicationId, | |
| int? deviceVmServicePort, | |
| String? deviceName, | |
| bool ipv6 = false, | |
| bool useDeviceIPAsHost = false, | |
| required Duration timeout, | |
| bool quitOnFind = false, | |
| }) async { | |
| _logger.printTrace('Checking for advertised Dart VM Services...'); | |
| try { | |
| await client.start(); | |
| final results = <MDnsVmServiceDiscoveryResult>[]; | |
| // uniqueDomainNames is used to track all domain names of Dart VM services | |
| // It is later used in this function to determine whether or not to throw an error. | |
| // We do not want to throw the error if it was unable to find any domain | |
| // names because that indicates it may be a problem with mDNS, which has | |
| // a separate error message in _checkForIPv4LinkLocal. | |
| final uniqueDomainNames = <String>{}; | |
| // uniqueDomainNamesInResults is used to filter out duplicates with exactly | |
| // the same domain name from the results. | |
| final uniqueDomainNamesInResults = <String>{}; | |
| // Listen for mDNS connections until timeout. | |
| final Stream<PtrResourceRecord> ptrResourceStream = client.lookup<PtrResourceRecord>( | |
| ResourceRecordQuery.serverPointer(dartVmServiceName), | |
| timeout: timeout, | |
| ); | |
| await for (final PtrResourceRecord ptr in ptrResourceStream) { | |
| uniqueDomainNames.add(ptr.domainName); | |
| String? domainName; | |
| if (applicationId != null) { | |
| // If applicationId is set, only use records that match it | |
| if (ptr.domainName.toLowerCase().startsWith(applicationId.toLowerCase())) { | |
| domainName = ptr.domainName; | |
| } else { | |
| continue; | |
| } | |
| } else { | |
| domainName = ptr.domainName; | |
| } | |
| // Result with same domain name was already found, skip it. | |
| if (uniqueDomainNamesInResults.contains(domainName)) { | |
| continue; | |
| } | |
| _logger.printTrace('Checking for available port on $domainName'); | |
| final List<SrvResourceRecord> srvRecords = await client | |
| .lookup<SrvResourceRecord>(ResourceRecordQuery.service(domainName)) | |
| .toList(); | |
| if (srvRecords.isEmpty) { | |
| continue; | |
| } | |
| // If more than one SrvResourceRecord found, it should just be a duplicate. | |
| final SrvResourceRecord srvRecord = srvRecords.first; | |
| if (srvRecords.length > 1) { | |
| _logger.printWarning( | |
| 'Unexpectedly found more than one Dart VM Service report for $domainName ' | |
| '- using first one (${srvRecord.port}).', | |
| ); | |
| } | |
| // If deviceVmServicePort is set, only use records that match it | |
| if (deviceVmServicePort != null && srvRecord.port != deviceVmServicePort) { | |
| continue; | |
| } | |
| // If deviceName is set, only use records that match it | |
| if (deviceName != null && !deviceNameMatchesTargetName(deviceName, srvRecord.target)) { | |
| continue; | |
| } | |
| // Get the IP address of the device if using the IP as the host. | |
| InternetAddress? ipAddress; | |
| if (useDeviceIPAsHost) { | |
| List<IPAddressResourceRecord> ipAddresses = await client | |
| .lookup<IPAddressResourceRecord>( | |
| ipv6 | |
| ? ResourceRecordQuery.addressIPv6(srvRecord.target) | |
| : ResourceRecordQuery.addressIPv4(srvRecord.target), | |
| ) | |
| .toList(); | |
| if (ipAddresses.isEmpty) { | |
| throwToolExit('Did not find IP for service ${srvRecord.target}.'); | |
| } | |
| // Filter out link-local addresses. | |
| if (ipAddresses.length > 1) { | |
| ipAddresses = ipAddresses | |
| .where((IPAddressResourceRecord element) => !element.address.isLinkLocal) | |
| .toList(); | |
| } | |
| ipAddress = ipAddresses.first.address; | |
| if (ipAddresses.length > 1) { | |
| _logger.printWarning( | |
| 'Unexpectedly found more than one IP for Dart VM Service ${srvRecord.target} ' | |
| '- using first one ($ipAddress).', | |
| ); | |
| } | |
| } | |
| _logger.printTrace('Checking for authentication code for $domainName'); | |
| final List<TxtResourceRecord> txt = await client | |
| .lookup<TxtResourceRecord>(ResourceRecordQuery.text(domainName)) | |
| .toList(); | |
| var authCode = ''; | |
| if (txt.isNotEmpty) { | |
| authCode = _getAuthCode(txt.first.text); | |
| } | |
| results.add( | |
| MDnsVmServiceDiscoveryResult(domainName, srvRecord.port, authCode, ipAddress: ipAddress), | |
| ); | |
| uniqueDomainNamesInResults.add(domainName); | |
| if (quitOnFind) { | |
| return results; | |
| } | |
| } | |
| // If applicationId is set and quitOnFind is true and no results matching | |
| // the applicationId were found but other results were found, throw an error. | |
| if (applicationId != null && quitOnFind && results.isEmpty && uniqueDomainNames.isNotEmpty) { | |
| var message = 'Did not find a Dart VM Service advertised for $applicationId'; | |
| if (deviceVmServicePort != null) { | |
| message += ' on port $deviceVmServicePort'; | |
| } | |
| throwToolExit('$message.'); | |
| } | |
| return results; | |
| } finally { | |
| client.stop(); | |
| } | |
| } | |
| @visibleForTesting | |
| bool deviceNameMatchesTargetName(String deviceName, String targetName) { | |
| // Remove `.local` from the name along with any non-word, non-digit characters. | |
| final cleanedNameRegex = RegExp(r'\.local|\W'); | |
| final String cleanedDeviceName = deviceName.trim().toLowerCase().replaceAll( | |
| cleanedNameRegex, | |
| '', | |
| ); | |
| final String cleanedTargetName = targetName.toLowerCase().replaceAll(cleanedNameRegex, ''); | |
| return cleanedDeviceName == cleanedTargetName; | |
| } | |
| String _getAuthCode(String txtRecord) { | |
| const authCodePrefix = 'authCode='; | |
| final Iterable<String> matchingRecords = LineSplitter.split( | |
| txtRecord, | |
| ).where((String record) => record.startsWith(authCodePrefix)); | |
| if (matchingRecords.isEmpty) { | |
| return ''; | |
| } | |
| String authCode = matchingRecords.first.substring(authCodePrefix.length); | |
| // The Dart VM Service currently expects a trailing '/' as part of the | |
| // URI, otherwise an invalid authentication code response is given. | |
| if (!authCode.endsWith('/')) { | |
| authCode += '/'; | |
| } | |
| return authCode; | |
| } | |
| /// Gets Dart VM Service Uri for `flutter attach`. | |
| /// Executes an mDNS query and waits until a Dart VM Service is found. | |
| /// | |
| /// When [useDeviceIPAsHost] is true, it will use the device's IP as the | |
| /// host and will not forward the port. | |
| /// | |
| /// Differs from [getVMServiceUriForLaunch] because it can search for any available Dart VM Service. | |
| /// Since [applicationId] and [deviceVmservicePort] are optional, it can either look for any service | |
| /// or a specific service matching [applicationId]/[deviceVmservicePort]. | |
| /// It may find more than one service, which will throw an error listing the found services. | |
| Future<Uri?> getVMServiceUriForAttach( | |
| String? applicationId, | |
| Device device, { | |
| bool usesIpv6 = false, | |
| int? hostVmservicePort, | |
| int? deviceVmservicePort, | |
| bool useDeviceIPAsHost = false, | |
| Duration timeout = const Duration(minutes: 10), | |
| }) async { | |
| final MDnsVmServiceDiscoveryResult? result = await queryForAttach( | |
| applicationId: applicationId, | |
| deviceVmservicePort: deviceVmservicePort, | |
| ipv6: usesIpv6, | |
| useDeviceIPAsHost: useDeviceIPAsHost, | |
| timeout: timeout, | |
| ); | |
| return _handleResult( | |
| result, | |
| device, | |
| applicationId: applicationId, | |
| deviceVmservicePort: deviceVmservicePort, | |
| hostVmservicePort: hostVmservicePort, | |
| usesIpv6: usesIpv6, | |
| useDeviceIPAsHost: useDeviceIPAsHost, | |
| ); | |
| } | |
| /// Gets Dart VM Service Uri for `flutter run`. | |
| /// Executes an mDNS query and waits until the Dart VM Service service is found. | |
| /// | |
| /// When [useDeviceIPAsHost] is true, it will use the device's IP as the | |
| /// host and will not forward the port. | |
| /// | |
| /// Differs from [getVMServiceUriForAttach] because it only searches for a specific service. | |
| /// This is enforced by [applicationId] being required and using either the | |
| /// [deviceVmservicePort] or the [device]'s name to query. | |
| Future<Uri?> getVMServiceUriForLaunch( | |
| String applicationId, | |
| Device device, { | |
| bool usesIpv6 = false, | |
| int? hostVmservicePort, | |
| int? deviceVmservicePort, | |
| bool useDeviceIPAsHost = false, | |
| Duration timeout = const Duration(minutes: 10), | |
| bool throwOnMissingLocalNetworkPermissionsError = true, | |
| }) async { | |
| final MDnsVmServiceDiscoveryResult? result = await queryForLaunch( | |
| applicationId: applicationId, | |
| deviceVmservicePort: deviceVmservicePort, | |
| deviceName: deviceVmservicePort == null ? device.name : null, | |
| ipv6: usesIpv6, | |
| useDeviceIPAsHost: useDeviceIPAsHost, | |
| timeout: timeout, | |
| throwOnMissingLocalNetworkPermissionsError: throwOnMissingLocalNetworkPermissionsError, | |
| ); | |
| return _handleResult( | |
| result, | |
| device, | |
| applicationId: applicationId, | |
| deviceVmservicePort: deviceVmservicePort, | |
| hostVmservicePort: hostVmservicePort, | |
| usesIpv6: usesIpv6, | |
| useDeviceIPAsHost: useDeviceIPAsHost, | |
| ); | |
| } | |
| Future<Uri?> _handleResult( | |
| MDnsVmServiceDiscoveryResult? result, | |
| Device device, { | |
| String? applicationId, | |
| int? deviceVmservicePort, | |
| int? hostVmservicePort, | |
| bool usesIpv6 = false, | |
| bool useDeviceIPAsHost = false, | |
| }) async { | |
| if (result == null) { | |
| await _checkForIPv4LinkLocal(device); | |
| return null; | |
| } | |
| final String host; | |
| final InternetAddress? ipAddress = result.ipAddress; | |
| if (useDeviceIPAsHost && ipAddress != null) { | |
| host = ipAddress.address; | |
| } else { | |
| host = usesIpv6 ? InternetAddress.loopbackIPv6.address : InternetAddress.loopbackIPv4.address; | |
| } | |
| return buildVMServiceUri( | |
| device, | |
| host, | |
| result.port, | |
| hostVmservicePort, | |
| result.authCode, | |
| useDeviceIPAsHost, | |
| ); | |
| } | |
| // If there's not an ipv4 link local address in `NetworkInterfaces.list`, | |
| // then request user interventions with a `printError()` if possible. | |
| Future<void> _checkForIPv4LinkLocal(Device device) async { | |
| _logger.printTrace( | |
| 'mDNS query failed. Checking for an interface with a ipv4 link local address.', | |
| ); | |
| final List<NetworkInterface> interfaces = await listNetworkInterfaces( | |
| includeLinkLocal: true, | |
| type: InternetAddressType.IPv4, | |
| ); | |
| if (_logger.isVerbose) { | |
| _logInterfaces(interfaces); | |
| } | |
| final bool hasIPv4LinkLocal = interfaces.any( | |
| (NetworkInterface interface) => | |
| interface.addresses.any((InternetAddress address) => address.isLinkLocal), | |
| ); | |
| if (hasIPv4LinkLocal) { | |
| _logger.printTrace('An interface with an ipv4 link local address was found.'); | |
| return; | |
| } | |
| final TargetPlatform targetPlatform = await device.targetPlatform; | |
| switch (targetPlatform) { | |
| case TargetPlatform.ios: | |
| _analytics.send( | |
| Event.appleUsageEvent(workflow: 'ios-mdns', parameter: 'no-ipv4-link-local'), | |
| ); | |
| _logger.printError( | |
| 'The mDNS query for an attached iOS device failed. It may ' | |
| 'be necessary to disable the "Personal Hotspot" on the device, and ' | |
| 'to ensure that the "Disable unless needed" setting is unchecked ' | |
| 'under System Preferences > Network > iPhone USB. ' | |
| 'See https://github.com/flutter/flutter/issues/46698 for details.', | |
| ); | |
| case TargetPlatform.android: | |
| case TargetPlatform.android_arm: | |
| case TargetPlatform.android_arm64: | |
| case TargetPlatform.android_x64: | |
| case TargetPlatform.darwin: | |
| case TargetPlatform.fuchsia_arm64: | |
| case TargetPlatform.fuchsia_x64: | |
| case TargetPlatform.linux_arm64: | |
| case TargetPlatform.linux_riscv64: | |
| case TargetPlatform.linux_x64: | |
| case TargetPlatform.tester: | |
| case TargetPlatform.web_javascript: | |
| case TargetPlatform.windows_x64: | |
| case TargetPlatform.windows_arm64: | |
| _logger.printTrace('No interface with an ipv4 link local address was found.'); | |
| case TargetPlatform.unsupported: | |
| TargetPlatform.throwUnsupportedTarget(); | |
| } | |
| } | |
| void _logInterfaces(List<NetworkInterface> interfaces) { | |
| for (final interface in interfaces) { | |
| if (_logger.isVerbose) { | |
| _logger.printTrace('Found interface "${interface.name}":'); | |
| for (final InternetAddress address in interface.addresses) { | |
| final linkLocal = address.isLinkLocal ? 'link local' : ''; | |
| _logger.printTrace('\tBound address: "${address.address}" $linkLocal'); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| class MDnsVmServiceDiscoveryResult { | |
| MDnsVmServiceDiscoveryResult(this.domainName, this.port, this.authCode, {this.ipAddress}); | |
| final String domainName; | |
| final int port; | |
| final String authCode; | |
| final InternetAddress? ipAddress; | |
| } | |
| Future<Uri> buildVMServiceUri( | |
| Device device, | |
| String host, | |
| int devicePort, [ | |
| int? hostVmservicePort, | |
| String? authCode, | |
| bool useDeviceIPAsHost = false, | |
| ]) async { | |
| var path = '/'; | |
| if (authCode != null) { | |
| path = authCode; | |
| } | |
| // Not having a trailing slash can cause problems in some situations. | |
| // Ensure that there's one present. | |
| if (!path.endsWith('/')) { | |
| path += '/'; | |
| } | |
| hostVmservicePort ??= 0; | |
| final int? actualHostPort; | |
| if (useDeviceIPAsHost) { | |
| // When using the device's IP as the host, port forwarding is not required | |
| // so just use the device's port. | |
| actualHostPort = devicePort; | |
| } else { | |
| actualHostPort = hostVmservicePort == 0 | |
| ? await device.portForwarder?.forward(devicePort) | |
| : hostVmservicePort; | |
| } | |
| return Uri(scheme: 'http', host: host, port: actualHostPort, path: path); | |
| } |