android_workflow.dart 17.3 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5 6
// @dart = 2.8

7
import 'package:meta/meta.dart';
8
import 'package:process/process.dart';
9

10
import '../base/common.dart';
11
import '../base/context.dart';
12
import '../base/file_system.dart';
13
import '../base/io.dart';
14 15
import '../base/logger.dart';
import '../base/os.dart';
16
import '../base/platform.dart';
17
import '../base/user_messages.dart' hide userMessages;
18
import '../base/version.dart';
19
import '../build_info.dart';
20
import '../convert.dart';
21
import '../doctor.dart';
22
import '../features.dart';
23
import 'android_sdk.dart';
24
import 'android_studio.dart';
25

26
const int kAndroidSdkMinVersion = 29;
27
final Version kAndroidJavaMinVersion = Version(1, 8, 0);
28 29
final Version kAndroidSdkBuildToolsMinVersion = Version(28, 0, 3);

30 31 32
AndroidWorkflow get androidWorkflow => context.get<AndroidWorkflow>();
AndroidValidator get androidValidator => context.get<AndroidValidator>();
AndroidLicenseValidator get androidLicenseValidator => context.get<AndroidLicenseValidator>();
33

34 35 36 37 38 39 40
enum LicensesAccepted {
  none,
  some,
  all,
  unknown,
}

41 42 43
final RegExp licenseCounts = RegExp(r'(\d+) of (\d+) SDK package licenses? not accepted.');
final RegExp licenseNotAccepted = RegExp(r'licenses? not accepted', caseSensitive: false);
final RegExp licenseAccepted = RegExp(r'All SDK package licenses accepted.');
44

45
class AndroidWorkflow implements Workflow {
46 47
  AndroidWorkflow({
    @required AndroidSdk androidSdk,
48
    @required FeatureFlags featureFlags,
49
    @required OperatingSystemUtils operatingSystemUtils,
50
  }) : _androidSdk = androidSdk,
51 52
       _featureFlags = featureFlags,
       _operatingSystemUtils = operatingSystemUtils;
53 54

  final AndroidSdk _androidSdk;
55
  final FeatureFlags _featureFlags;
56
  final OperatingSystemUtils _operatingSystemUtils;
57

58
  @override
59 60 61
  bool get appliesToHostPlatform => _featureFlags.isAndroidEnabled
    // Android Studio is not currently supported on Linux Arm64 Hosts.
    && _operatingSystemUtils.hostPlatform != HostPlatform.linux_arm64;
62

63
  @override
64 65
  bool get canListDevices => _androidSdk != null
    && _androidSdk.adbPath != null;
66

67
  @override
68 69 70
  bool get canLaunchDevices => _androidSdk != null
    && _androidSdk.adbPath != null
    && _androidSdk.validateSdkWellFormed().isEmpty;
71

72
  @override
73 74 75
  bool get canListEmulators => _androidSdk != null
    && _androidSdk.adbPath != null
    && _androidSdk.emulatorPath != null;
76 77
}

78 79 80 81 82 83 84
/// A validator that checks if the Android SDK and Java SDK are available and
/// installed correctly.
///
/// Android development requires the Android SDK, and at least one Java SDK. While
/// newer Java compilers can be used to compile the Java application code, the SDK
/// tools themselves required JDK 1.8. This older JDK is normally bundled with
/// Android Studio.
85
class AndroidValidator extends DoctorValidator {
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
  AndroidValidator({
    @required AndroidSdk androidSdk,
    @required AndroidStudio androidStudio,
    @required FileSystem fileSystem,
    @required Logger logger,
    @required Platform platform,
    @required ProcessManager processManager,
    @required UserMessages userMessages,
  }) : _androidSdk = androidSdk,
       _androidStudio = androidStudio,
       _fileSystem = fileSystem,
       _logger = logger,
       _operatingSystemUtils = OperatingSystemUtils(
         fileSystem: fileSystem,
         logger: logger,
         platform: platform,
         processManager: processManager,
       ),
       _platform = platform,
       _processManager = processManager,
       _userMessages = userMessages,
       super('Android toolchain - develop for Android devices');

  final AndroidSdk _androidSdk;
  final AndroidStudio _androidStudio;
  final FileSystem _fileSystem;
  final Logger _logger;
  final OperatingSystemUtils _operatingSystemUtils;
  final Platform _platform;
  final ProcessManager _processManager;
  final UserMessages _userMessages;
117

118 119 120 121
  @override
  String get slowWarning => '${_task ?? 'This'} is taking a long time...';
  String _task;

122 123 124 125 126 127 128 129 130 131 132
  /// Finds the semantic version anywhere in a text.
  static final RegExp _javaVersionPattern = RegExp(r'(\d+)(\.(\d+)(\.(\d+))?)?');

  /// `java -version` response is not only a number, but also includes other
  /// information eg. `openjdk version "1.7.0_212"`.
  /// This method extracts only the semantic version from from that response.
  static String _extractJavaVersion(String text) {
    final Match match = _javaVersionPattern.firstMatch(text ?? '');
    return text?.substring(match.start, match.end);
  }

133
  /// Returns false if we cannot determine the Java version or if the version
134
  /// is older that the minimum allowed version of 1.8.
135
  Future<bool> _checkJavaVersion(String javaBinary, List<ValidationMessage> messages) async {
136
    _task = 'Checking Java status';
137
    try {
138 139
      if (!_processManager.canRun(javaBinary)) {
        messages.add(ValidationMessage.error(_userMessages.androidCantRunJavaBinary(javaBinary)));
140
        return false;
141
      }
142
      String javaVersionText;
143
      try {
144 145
        _logger.printTrace('java -version');
        final ProcessResult result = await _processManager.run(<String>[javaBinary, '-version']);
146
        if (result.exitCode == 0) {
147
          final List<String> versionLines = (result.stderr as String).split('\n');
148
          javaVersionText = versionLines.length >= 2 ? versionLines[1] : versionLines[0];
149
        }
150
      } on Exception catch (error) {
151
        _logger.printTrace(error.toString());
152
      }
153
      if (javaVersionText == null || javaVersionText.isEmpty) {
154
        // Could not determine the java version.
155
        messages.add(ValidationMessage.error(_userMessages.androidUnknownJavaVersion));
156 157
        return false;
      }
158 159
      final Version javaVersion = Version.parse(_extractJavaVersion(javaVersionText));
      if (javaVersion < kAndroidJavaMinVersion) {
160
        messages.add(ValidationMessage.error(_userMessages.androidJavaMinimumVersion(javaVersionText)));
161 162
        return false;
      }
163
      messages.add(ValidationMessage(_userMessages.androidJavaVersion(javaVersionText)));
164 165 166
      return true;
    } finally {
      _task = null;
167 168 169
    }
  }

170
  @override
171
  Future<ValidationResult> validate() async {
172
    final List<ValidationMessage> messages = <ValidationMessage>[];
173

174
    if (_androidSdk == null) {
175
      // No Android SDK found.
176 177 178
      if (_platform.environment.containsKey(kAndroidHome)) {
        final String androidHomeDir = _platform.environment[kAndroidHome];
        messages.add(ValidationMessage.error(_userMessages.androidBadSdkDir(kAndroidHome, androidHomeDir)));
179
      } else {
180 181
        // Instruct user to set [kAndroidSdkRoot] and not deprecated [kAndroidHome]
        // See https://github.com/flutter/flutter/issues/39301
182
        messages.add(ValidationMessage.error(_userMessages.androidMissingSdkInstructions(_platform)));
183
      }
184
      return ValidationResult(ValidationType.missing, messages);
185
    }
186

187 188
    if (_androidSdk.licensesAvailable && !_androidSdk.platformToolsAvailable) {
      messages.add(ValidationMessage.hint(_userMessages.androidSdkLicenseOnly(kAndroidHome)));
189 190 191
      return ValidationResult(ValidationType.partial, messages);
    }

192
    messages.add(ValidationMessage(_userMessages.androidSdkLocation(_androidSdk.directory?.path)));
193

194
    String sdkVersionText;
195
    if (_androidSdk.latestVersion != null) {
196
      if (_androidSdk.latestVersion.sdkLevel < kAndroidSdkMinVersion || _androidSdk.latestVersion.buildToolsVersion < kAndroidSdkBuildToolsMinVersion) {
197
        messages.add(ValidationMessage.error(
198 199 200 201 202 203
          _userMessages.androidSdkBuildToolsOutdated(
            _androidSdk.sdkManagerPath,
            kAndroidSdkMinVersion,
            kAndroidSdkBuildToolsMinVersion.toString(),
            _platform,
          )),
204 205 206
        );
        return ValidationResult(ValidationType.missing, messages);
      }
207
      sdkVersionText = _userMessages.androidStatusInfo(_androidSdk.latestVersion.buildToolsVersionName);
208

209 210 211
      messages.add(ValidationMessage(_userMessages.androidSdkPlatformToolsVersion(
        _androidSdk.latestVersion.platformName,
        _androidSdk.latestVersion.buildToolsVersionName)));
212
    } else {
213
      messages.add(ValidationMessage.error(_userMessages.androidMissingSdkInstructions(_platform)));
214
    }
215

216 217
    if (_platform.environment.containsKey(kAndroidHome)) {
      final String androidHomeDir = _platform.environment[kAndroidHome];
218
      messages.add(ValidationMessage('$kAndroidHome = $androidHomeDir'));
219
    }
220 221
    if (_platform.environment.containsKey(kAndroidSdkRoot)) {
      final String androidSdkRoot = _platform.environment[kAndroidSdkRoot];
222 223
      messages.add(ValidationMessage('$kAndroidSdkRoot = $androidSdkRoot'));
    }
224

225
    final List<String> validationResult = _androidSdk.validateSdkWellFormed();
226

227 228
    if (validationResult.isNotEmpty) {
      // Android SDK is not functional.
229
      messages.addAll(validationResult.map<ValidationMessage>((String message) {
230
        return ValidationMessage.error(message);
231
      }));
232
      messages.add(ValidationMessage(_userMessages.androidSdkInstallHelp(_platform)));
233
      return ValidationResult(ValidationType.partial, messages, statusInfo: sdkVersionText);
234 235 236
    }

    // Now check for the JDK.
237 238 239 240 241 242
    final String javaBinary = AndroidSdk.findJavaBinary(
      androidStudio: _androidStudio,
      fileSystem: _fileSystem,
      operatingSystemUtils: _operatingSystemUtils,
      platform: _platform,
    );
243
    if (javaBinary == null) {
244
      messages.add(ValidationMessage.error(_userMessages.androidMissingJdk));
245
      return ValidationResult(ValidationType.partial, messages, statusInfo: sdkVersionText);
246
    }
247
    messages.add(ValidationMessage(_userMessages.androidJdkLocation(javaBinary)));
248 249

    // Check JDK version.
250
    if (! await _checkJavaVersion(javaBinary, messages)) {
251
      return ValidationResult(ValidationType.partial, messages, statusInfo: sdkVersionText);
252 253
    }

254 255 256 257 258
    // Success.
    return ValidationResult(ValidationType.installed, messages, statusInfo: sdkVersionText);
  }
}

259 260
/// A subvalidator that checks if the licenses within the detected Android
/// SDK have been accepted.
261
class AndroidLicenseValidator extends DoctorValidator {
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
  AndroidLicenseValidator({
    @required AndroidSdk androidSdk,
    @required Platform platform,
    @required OperatingSystemUtils operatingSystemUtils,
    @required FileSystem fileSystem,
    @required ProcessManager processManager,
    @required Logger logger,
    @required AndroidStudio androidStudio,
    @required Stdio stdio,
    @required UserMessages userMessages,
  }) : _androidSdk = androidSdk,
       _platform = platform,
       _operatingSystemUtils = operatingSystemUtils,
       _fileSystem = fileSystem,
       _processManager = processManager,
       _logger = logger,
       _androidStudio = androidStudio,
       _stdio = stdio,
       _userMessages = userMessages,
       super('Android license subvalidator');

  final AndroidSdk _androidSdk;
  final AndroidStudio _androidStudio;
  final Stdio _stdio;
  final OperatingSystemUtils _operatingSystemUtils;
  final Platform _platform;
  final FileSystem _fileSystem;
  final ProcessManager _processManager;
  final Logger _logger;
  final UserMessages _userMessages;
292

293 294 295
  @override
  String get slowWarning => 'Checking Android licenses is taking an unexpectedly long time...';

296 297 298 299 300
  @override
  Future<ValidationResult> validate() async {
    final List<ValidationMessage> messages = <ValidationMessage>[];

    // Match pre-existing early termination behavior
301 302
    if (_androidSdk == null || _androidSdk.latestVersion == null ||
        _androidSdk.validateSdkWellFormed().isNotEmpty ||
303 304 305 306
        ! await _checkJavaVersionNoOutput()) {
      return ValidationResult(ValidationType.missing, messages);
    }

307
    final String sdkVersionText = _userMessages.androidStatusInfo(_androidSdk.latestVersion.buildToolsVersionName);
308

309 310 311
    // Check for licenses.
    switch (await licensesAccepted) {
      case LicensesAccepted.all:
312
        messages.add(ValidationMessage(_userMessages.androidLicensesAll));
313 314
        break;
      case LicensesAccepted.some:
315
        messages.add(ValidationMessage.hint(_userMessages.androidLicensesSome));
316
        return ValidationResult(ValidationType.partial, messages, statusInfo: sdkVersionText);
317
      case LicensesAccepted.none:
318
        messages.add(ValidationMessage.error(_userMessages.androidLicensesNone));
319
        return ValidationResult(ValidationType.partial, messages, statusInfo: sdkVersionText);
320
      case LicensesAccepted.unknown:
321
        messages.add(ValidationMessage.error(_userMessages.androidLicensesUnknown(_platform)));
322
        return ValidationResult(ValidationType.partial, messages, statusInfo: sdkVersionText);
323
    }
324
    return ValidationResult(ValidationType.installed, messages, statusInfo: sdkVersionText);
325
  }
326

327
  Future<bool> _checkJavaVersionNoOutput() async {
328
    final String javaBinary = AndroidSdk.findJavaBinary(
329 330 331 332
      androidStudio: _androidStudio,
      fileSystem: _fileSystem,
      operatingSystemUtils: _operatingSystemUtils,
      platform: _platform,
333
    );
334 335 336
    if (javaBinary == null) {
      return false;
    }
337
    if (!_processManager.canRun(javaBinary)) {
338 339 340 341
      return false;
    }
    String javaVersion;
    try {
342
      final ProcessResult result = await _processManager.run(<String>[javaBinary, '-version']);
343
      if (result.exitCode == 0) {
344
        final List<String> versionLines = (result.stderr as String).split('\n');
345 346
        javaVersion = versionLines.length >= 2 ? versionLines[1] : versionLines[0];
      }
347
    } on Exception catch (error) {
348
      _logger.printTrace(error.toString());
349 350 351 352 353 354 355 356
    }
    if (javaVersion == null) {
      // Could not determine the java version.
      return false;
    }
    return true;
  }

357
  Future<LicensesAccepted> get licensesAccepted async {
358
    LicensesAccepted status;
359

360 361
    void _handleLine(String line) {
      if (licenseCounts.hasMatch(line)) {
362 363 364 365 366 367 368
        final Match match = licenseCounts.firstMatch(line);
        if (match.group(1) != match.group(2)) {
          status = LicensesAccepted.some;
        } else {
          status = LicensesAccepted.none;
        }
      } else if (licenseNotAccepted.hasMatch(line)) {
369 370 371
        // The licenseNotAccepted pattern is trying to match the same line as
        // licenseCounts, but is more general. In case the format changes, a
        // more general match may keep doctor mostly working.
372
        status = LicensesAccepted.none;
373 374
      } else if (licenseAccepted.hasMatch(line)) {
        status ??= LicensesAccepted.all;
375 376 377
      }
    }

378 379 380
    if (!_canRunSdkManager()) {
      return LicensesAccepted.unknown;
    }
381

382
    try {
383 384 385
      final Process process = await _processManager.start(
        <String>[_androidSdk.sdkManagerPath, '--licenses'],
        environment: _androidSdk.sdkManagerEnv,
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
      );
      process.stdin.write('n\n');
      // We expect logcat streams to occasionally contain invalid utf-8,
      // see: https://github.com/flutter/flutter/pull/8864.
      final Future<void> output = process.stdout
        .transform<String>(const Utf8Decoder(reportErrors: false))
        .transform<String>(const LineSplitter())
        .listen(_handleLine)
        .asFuture<void>(null);
      final Future<void> errors = process.stderr
        .transform<String>(const Utf8Decoder(reportErrors: false))
        .transform<String>(const LineSplitter())
        .listen(_handleLine)
        .asFuture<void>(null);
      await Future.wait<void>(<Future<void>>[output, errors]);
      return status ?? LicensesAccepted.unknown;
    } on ProcessException catch (e) {
403
      _logger.printTrace('Failed to run Android sdk manager: $e');
404 405
      return LicensesAccepted.unknown;
    }
406 407
  }

408
  /// Run the Android SDK manager tool in order to accept SDK licenses.
409 410 411
  Future<bool> runLicenseManager() async {
    if (_androidSdk == null) {
      _logger.printStatus(_userMessages.androidSdkShort);
412 413 414
      return false;
    }

415
    if (!_canRunSdkManager()) {
416
      throwToolExit(_userMessages.androidMissingSdkManager(_androidSdk.sdkManagerPath, _platform));
417
    }
418

419
    try {
420 421 422
      final Process process = await _processManager.start(
        <String>[_androidSdk.sdkManagerPath, '--licenses'],
        environment: _androidSdk.sdkManagerEnv,
423 424 425 426
      );

      // The real stdin will never finish streaming. Pipe until the child process
      // finishes.
427
      unawaited(process.stdin.addStream(_stdio.stdin)
428 429 430
        // If the process exits unexpectedly with an error, that will be
        // handled by the caller.
        .catchError((dynamic err, StackTrace stack) {
431 432
          _logger.printTrace('Echoing stdin to the licenses subprocess failed:');
          _logger.printTrace('$err\n$stack');
433 434 435
        }
      ));

436 437
      // Wait for stdout and stderr to be fully processed, because process.exitCode
      // may complete first.
438
      try {
439
        await Future.wait<void>(<Future<void>>[
440 441
          _stdio.addStdoutStream(process.stdout),
          _stdio.addStderrStream(process.stderr),
442
        ]);
443
      } on Exception catch (err, stack) {
444 445
        _logger.printTrace('Echoing stdout or stderr from the license subprocess failed:');
        _logger.printTrace('$err\n$stack');
446
      }
447 448 449 450

      final int exitCode = await process.exitCode;
      return exitCode == 0;
    } on ProcessException catch (e) {
451 452
      throwToolExit(_userMessages.androidCannotRunSdkManager(
        _androidSdk.sdkManagerPath,
453
        e.toString(),
454
        _platform,
455
      ));
456 457
      return false;
    }
458
  }
459

460 461 462
  bool _canRunSdkManager() {
    final String sdkManagerPath = _androidSdk.sdkManagerPath;
    return _processManager.canRun(sdkManagerPath);
463
  }
464
}