5491c8c146
This auto-formats all *.dart files in the repository outside of the `engine` subdirectory and enforces that these files stay formatted with a presubmit check. **Reviewers:** Please carefully review all the commits except for the one titled "formatted". The "formatted" commit was auto-generated by running `dev/tools/format.sh -a -f`. The other commits were hand-crafted to prepare the repo for the formatting change. I recommend reviewing the commits one-by-one via the "Commits" tab and avoiding Github's "Files changed" tab as it will likely slow down your browser because of the size of this PR. --------- Co-authored-by: Kate Lovett <katelovett@google.com> Co-authored-by: LongCatIsLooong <31859944+LongCatIsLooong@users.noreply.github.com>
630 lines
21 KiB
Dart
630 lines
21 KiB
Dart
// 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 '../base/common.dart';
|
|
import '../base/config.dart';
|
|
import '../base/file_system.dart';
|
|
import '../base/platform.dart';
|
|
import '../base/process.dart';
|
|
import '../base/version.dart';
|
|
import '../convert.dart';
|
|
import '../globals.dart' as globals;
|
|
import 'java.dart';
|
|
|
|
// ANDROID_SDK_ROOT is deprecated.
|
|
// See https://developer.android.com/studio/command-line/variables.html#envar
|
|
const String kAndroidSdkRoot = 'ANDROID_SDK_ROOT';
|
|
const String kAndroidHome = 'ANDROID_HOME';
|
|
|
|
// No official environment variable for the NDK root is documented:
|
|
// https://developer.android.com/tools/variables#envar
|
|
// The follow three seem to be most commonly used.
|
|
const String kAndroidNdkHome = 'ANDROID_NDK_HOME';
|
|
const String kAndroidNdkPath = 'ANDROID_NDK_PATH';
|
|
const String kAndroidNdkRoot = 'ANDROID_NDK_ROOT';
|
|
|
|
final RegExp _numberedAndroidPlatformRe = RegExp(r'^android-([0-9]+)$');
|
|
final RegExp _sdkVersionRe = RegExp(r'^ro.build.version.sdk=([0-9]+)$');
|
|
|
|
// Android SDK layout:
|
|
|
|
// $ANDROID_HOME/platform-tools/adb
|
|
|
|
// $ANDROID_HOME/build-tools/19.1.0/aapt, dx, zipalign
|
|
// $ANDROID_HOME/build-tools/22.0.1/aapt
|
|
// $ANDROID_HOME/build-tools/23.0.2/aapt
|
|
// $ANDROID_HOME/build-tools/24.0.0-preview/aapt
|
|
// $ANDROID_HOME/build-tools/25.0.2/apksigner
|
|
|
|
// $ANDROID_HOME/platforms/android-22/android.jar
|
|
// $ANDROID_HOME/platforms/android-23/android.jar
|
|
// $ANDROID_HOME/platforms/android-N/android.jar
|
|
class AndroidSdk {
|
|
AndroidSdk(this.directory, {Java? java, FileSystem? fileSystem}) : _java = java {
|
|
reinitialize(fileSystem: fileSystem);
|
|
}
|
|
|
|
/// The Android SDK root directory.
|
|
final Directory directory;
|
|
|
|
final Java? _java;
|
|
|
|
List<AndroidSdkVersion> _sdkVersions = <AndroidSdkVersion>[];
|
|
AndroidSdkVersion? _latestVersion;
|
|
|
|
/// Whether the `cmdline-tools` directory exists in the Android SDK.
|
|
///
|
|
/// This is required to use the newest SDK manager which only works with
|
|
/// the newer JDK.
|
|
bool get cmdlineToolsAvailable => directory.childDirectory('cmdline-tools').existsSync();
|
|
|
|
/// Whether the `platform-tools` or `cmdline-tools` directory exists in the Android SDK.
|
|
///
|
|
/// It is possible to have an Android SDK folder that is missing this with
|
|
/// the expectation that it will be downloaded later, e.g. by gradle or the
|
|
/// sdkmanager. The [licensesAvailable] property should be used to determine
|
|
/// whether the licenses are at least possibly accepted.
|
|
bool get platformToolsAvailable =>
|
|
cmdlineToolsAvailable || directory.childDirectory('platform-tools').existsSync();
|
|
|
|
/// Whether the `licenses` directory exists in the Android SDK.
|
|
///
|
|
/// The existence of this folder normally indicates that the SDK licenses have
|
|
/// been accepted, e.g. via the sdkmanager, Android Studio, or by copying them
|
|
/// from another workstation such as in CI scenarios. If these files are valid
|
|
/// gradle or the sdkmanager will be able to download and use other parts of
|
|
/// the SDK on demand.
|
|
bool get licensesAvailable => directory.childDirectory('licenses').existsSync();
|
|
|
|
static AndroidSdk? locateAndroidSdk() {
|
|
String? findAndroidHomeDir() {
|
|
String? androidHomeDir;
|
|
if (globals.config.containsKey('android-sdk')) {
|
|
androidHomeDir = globals.config.getValue('android-sdk') as String?;
|
|
} else if (globals.platform.environment.containsKey(kAndroidHome)) {
|
|
androidHomeDir = globals.platform.environment[kAndroidHome];
|
|
} else if (globals.platform.environment.containsKey(kAndroidSdkRoot)) {
|
|
androidHomeDir = globals.platform.environment[kAndroidSdkRoot];
|
|
} else if (globals.platform.isLinux) {
|
|
if (globals.fsUtils.homeDirPath != null) {
|
|
androidHomeDir = globals.fs.path.join(globals.fsUtils.homeDirPath!, 'Android', 'Sdk');
|
|
}
|
|
} else if (globals.platform.isMacOS) {
|
|
if (globals.fsUtils.homeDirPath != null) {
|
|
androidHomeDir = globals.fs.path.join(
|
|
globals.fsUtils.homeDirPath!,
|
|
'Library',
|
|
'Android',
|
|
'sdk',
|
|
);
|
|
}
|
|
} else if (globals.platform.isWindows) {
|
|
if (globals.fsUtils.homeDirPath != null) {
|
|
androidHomeDir = globals.fs.path.join(
|
|
globals.fsUtils.homeDirPath!,
|
|
'AppData',
|
|
'Local',
|
|
'Android',
|
|
'sdk',
|
|
);
|
|
}
|
|
}
|
|
|
|
if (androidHomeDir != null) {
|
|
if (validSdkDirectory(androidHomeDir)) {
|
|
return androidHomeDir;
|
|
}
|
|
if (validSdkDirectory(globals.fs.path.join(androidHomeDir, 'sdk'))) {
|
|
return globals.fs.path.join(androidHomeDir, 'sdk');
|
|
}
|
|
}
|
|
|
|
// in build-tools/$version/aapt
|
|
final List<File> aaptBins = globals.os.whichAll('aapt');
|
|
for (File aaptBin in aaptBins) {
|
|
// Make sure we're using the aapt from the SDK.
|
|
aaptBin = globals.fs.file(aaptBin.resolveSymbolicLinksSync());
|
|
final String dir = aaptBin.parent.parent.parent.path;
|
|
if (validSdkDirectory(dir)) {
|
|
return dir;
|
|
}
|
|
}
|
|
|
|
// in platform-tools/adb
|
|
final List<File> adbBins = globals.os.whichAll('adb');
|
|
for (File adbBin in adbBins) {
|
|
// Make sure we're using the adb from the SDK.
|
|
adbBin = globals.fs.file(adbBin.resolveSymbolicLinksSync());
|
|
final String dir = adbBin.parent.parent.path;
|
|
if (validSdkDirectory(dir)) {
|
|
return dir;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
final String? androidHomeDir = findAndroidHomeDir();
|
|
if (androidHomeDir == null) {
|
|
// No dice.
|
|
globals.printTrace('Unable to locate an Android SDK.');
|
|
return null;
|
|
}
|
|
|
|
return AndroidSdk(globals.fs.directory(androidHomeDir));
|
|
}
|
|
|
|
static bool validSdkDirectory(String dir) {
|
|
return sdkDirectoryHasLicenses(dir) || sdkDirectoryHasPlatformTools(dir);
|
|
}
|
|
|
|
static bool sdkDirectoryHasPlatformTools(String dir) {
|
|
return globals.fs.isDirectorySync(globals.fs.path.join(dir, 'platform-tools'));
|
|
}
|
|
|
|
static bool sdkDirectoryHasLicenses(String dir) {
|
|
return globals.fs.isDirectorySync(globals.fs.path.join(dir, 'licenses'));
|
|
}
|
|
|
|
List<AndroidSdkVersion> get sdkVersions => _sdkVersions;
|
|
|
|
AndroidSdkVersion? get latestVersion => _latestVersion;
|
|
|
|
late final String? adbPath = getPlatformToolsPath(globals.platform.isWindows ? 'adb.exe' : 'adb');
|
|
|
|
String? get emulatorPath => getEmulatorPath();
|
|
|
|
String? get avdManagerPath => getAvdManagerPath();
|
|
|
|
/// Locate the path for storing AVD emulator images. Returns null if none found.
|
|
String? getAvdPath() {
|
|
final String? avdHome = globals.platform.environment['ANDROID_AVD_HOME'];
|
|
final String? home = globals.platform.environment['HOME'];
|
|
final List<String> searchPaths = <String>[
|
|
if (avdHome != null) avdHome,
|
|
if (home != null) globals.fs.path.join(home, '.android', 'avd'),
|
|
];
|
|
|
|
if (globals.platform.isWindows) {
|
|
final String? homeDrive = globals.platform.environment['HOMEDRIVE'];
|
|
final String? homePath = globals.platform.environment['HOMEPATH'];
|
|
|
|
if (homeDrive != null && homePath != null) {
|
|
// Can't use path.join for HOMEDRIVE/HOMEPATH
|
|
// https://github.com/dart-lang/path/issues/37
|
|
final String home = homeDrive + homePath;
|
|
searchPaths.add(globals.fs.path.join(home, '.android', 'avd'));
|
|
}
|
|
}
|
|
|
|
for (final String searchPath in searchPaths) {
|
|
if (globals.fs.directory(searchPath).existsSync()) {
|
|
return searchPath;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
Directory get _platformsDir => directory.childDirectory('platforms');
|
|
|
|
Iterable<Directory> get _platforms {
|
|
Iterable<Directory> platforms = <Directory>[];
|
|
if (_platformsDir.existsSync()) {
|
|
platforms = _platformsDir.listSync().whereType<Directory>();
|
|
}
|
|
return platforms;
|
|
}
|
|
|
|
/// Validate the Android SDK. This returns an empty list if there are no
|
|
/// issues; otherwise, it returns a list of issues found.
|
|
List<String> validateSdkWellFormed() {
|
|
if (adbPath == null || !globals.processManager.canRun(adbPath)) {
|
|
return <String>['Android SDK file not found: ${adbPath ?? 'adb'}.'];
|
|
}
|
|
|
|
if (sdkVersions.isEmpty || latestVersion == null) {
|
|
final StringBuffer msg = StringBuffer(
|
|
'No valid Android SDK platforms found in ${_platformsDir.path}.',
|
|
);
|
|
if (_platforms.isEmpty) {
|
|
msg.write(' Directory was empty.');
|
|
} else {
|
|
msg.write(' Candidates were:\n');
|
|
msg.write(_platforms.map((Directory dir) => ' - ${dir.basename}').join('\n'));
|
|
}
|
|
return <String>[msg.toString()];
|
|
}
|
|
|
|
return latestVersion!.validateSdkWellFormed();
|
|
}
|
|
|
|
String? getPlatformToolsPath(String binaryName) {
|
|
final File cmdlineToolsBinary = directory.childDirectory('cmdline-tools').childFile(binaryName);
|
|
if (cmdlineToolsBinary.existsSync()) {
|
|
return cmdlineToolsBinary.path;
|
|
}
|
|
final File platformToolBinary = directory
|
|
.childDirectory('platform-tools')
|
|
.childFile(binaryName);
|
|
if (platformToolBinary.existsSync()) {
|
|
return platformToolBinary.path;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
String? getEmulatorPath() {
|
|
final String binaryName = globals.platform.isWindows ? 'emulator.exe' : 'emulator';
|
|
// Emulator now lives inside "emulator" but used to live inside "tools" so
|
|
// try both.
|
|
final List<String> searchFolders = <String>['emulator', 'tools'];
|
|
for (final String folder in searchFolders) {
|
|
final File file = directory.childDirectory(folder).childFile(binaryName);
|
|
if (file.existsSync()) {
|
|
return file.path;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
String? getCmdlineToolsPath(String binaryName, {bool skipOldTools = false}) {
|
|
// First look for the latest version of the command-line tools
|
|
final File cmdlineToolsLatestBinary = directory
|
|
.childDirectory('cmdline-tools')
|
|
.childDirectory('latest')
|
|
.childDirectory('bin')
|
|
.childFile(binaryName);
|
|
if (cmdlineToolsLatestBinary.existsSync()) {
|
|
return cmdlineToolsLatestBinary.path;
|
|
}
|
|
|
|
// Next look for the highest version of the command-line tools
|
|
final Directory cmdlineToolsDir = directory.childDirectory('cmdline-tools');
|
|
if (cmdlineToolsDir.existsSync()) {
|
|
final List<Version> cmdlineTools =
|
|
cmdlineToolsDir
|
|
.listSync()
|
|
.whereType<Directory>()
|
|
.map((Directory subDirectory) {
|
|
try {
|
|
return Version.parse(subDirectory.basename);
|
|
} on Exception {
|
|
return null;
|
|
}
|
|
})
|
|
.whereType<Version>()
|
|
.toList();
|
|
cmdlineTools.sort();
|
|
|
|
for (final Version cmdlineToolsVersion in cmdlineTools.reversed) {
|
|
final File cmdlineToolsBinary = directory
|
|
.childDirectory('cmdline-tools')
|
|
.childDirectory(cmdlineToolsVersion.toString())
|
|
.childDirectory('bin')
|
|
.childFile(binaryName);
|
|
if (cmdlineToolsBinary.existsSync()) {
|
|
return cmdlineToolsBinary.path;
|
|
}
|
|
}
|
|
}
|
|
if (skipOldTools) {
|
|
return null;
|
|
}
|
|
|
|
// Finally fallback to the old SDK tools
|
|
final File toolsBinary = directory
|
|
.childDirectory('tools')
|
|
.childDirectory('bin')
|
|
.childFile(binaryName);
|
|
if (toolsBinary.existsSync()) {
|
|
return toolsBinary.path;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
String? getAvdManagerPath() =>
|
|
getCmdlineToolsPath(globals.platform.isWindows ? 'avdmanager.bat' : 'avdmanager');
|
|
|
|
/// From https://developer.android.com/ndk/guides/other_build_systems.
|
|
static const Map<String, String> _llvmHostDirectoryName = <String, String>{
|
|
'macos': 'darwin-x86_64',
|
|
'linux': 'linux-x86_64',
|
|
'windows': 'windows-x86_64',
|
|
};
|
|
|
|
/// Locates the binary path for an NDK binary.
|
|
///
|
|
/// The order of resolution is as follows:
|
|
///
|
|
/// 1. If [globals.config] defines an `'android-ndk'` use that.
|
|
/// 2. If the environment variable `ANDROID_NDK_HOME` is defined, use that.
|
|
/// 3. If the environment variable `ANDROID_NDK_PATH` is defined, use that.
|
|
/// 4. If the environment variable `ANDROID_NDK_ROOT` is defined, use that.
|
|
/// 5. Look for the default install location inside the Android SDK:
|
|
/// [directory]/ndk/\<version\>/. If multiple versions exist, use the
|
|
/// newest.
|
|
String? getNdkBinaryPath(String binaryName, {Platform? platform, Config? config}) {
|
|
platform ??= globals.platform;
|
|
config ??= globals.config;
|
|
Directory? findAndroidNdkHomeDir() {
|
|
String? androidNdkHomeDir;
|
|
if (config!.containsKey('android-ndk')) {
|
|
androidNdkHomeDir = config.getValue('android-ndk') as String?;
|
|
} else if (platform!.environment.containsKey(kAndroidNdkHome)) {
|
|
androidNdkHomeDir = platform.environment[kAndroidNdkHome];
|
|
} else if (platform.environment.containsKey(kAndroidNdkPath)) {
|
|
androidNdkHomeDir = platform.environment[kAndroidNdkPath];
|
|
} else if (platform.environment.containsKey(kAndroidNdkRoot)) {
|
|
androidNdkHomeDir = platform.environment[kAndroidNdkRoot];
|
|
}
|
|
if (androidNdkHomeDir != null) {
|
|
return directory.fileSystem.directory(androidNdkHomeDir);
|
|
}
|
|
|
|
// Look for the default install location of the NDK inside the Android
|
|
// SDK when installed through `sdkmanager` or Android studio.
|
|
final Directory ndk = directory.childDirectory('ndk');
|
|
if (!ndk.existsSync()) {
|
|
return null;
|
|
}
|
|
final List<Version> ndkVersions =
|
|
ndk
|
|
.listSync()
|
|
.map((FileSystemEntity entity) {
|
|
try {
|
|
return Version.parse(entity.basename);
|
|
} on Exception {
|
|
return null;
|
|
}
|
|
})
|
|
.whereType<Version>()
|
|
.toList()
|
|
// Use latest NDK first.
|
|
..sort((Version a, Version b) => -a.compareTo(b));
|
|
if (ndkVersions.isEmpty) {
|
|
return null;
|
|
}
|
|
return ndk.childDirectory(ndkVersions.first.toString());
|
|
}
|
|
|
|
final Directory? androidNdkHomeDir = findAndroidNdkHomeDir();
|
|
if (androidNdkHomeDir == null) {
|
|
return null;
|
|
}
|
|
final File executable = androidNdkHomeDir
|
|
.childDirectory('toolchains')
|
|
.childDirectory('llvm')
|
|
.childDirectory('prebuilt')
|
|
.childDirectory(_llvmHostDirectoryName[platform.operatingSystem]!)
|
|
.childDirectory('bin')
|
|
.childFile(binaryName);
|
|
if (executable.existsSync()) {
|
|
// LLVM missing in this NDK version.
|
|
return executable.path;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
String? getNdkClangPath({Platform? platform, Config? config}) {
|
|
platform ??= globals.platform;
|
|
return getNdkBinaryPath(
|
|
platform.isWindows ? 'clang.exe' : 'clang',
|
|
platform: platform,
|
|
config: config,
|
|
);
|
|
}
|
|
|
|
String? getNdkArPath({Platform? platform, Config? config}) {
|
|
platform ??= globals.platform;
|
|
return getNdkBinaryPath(
|
|
platform.isWindows ? 'llvm-ar.exe' : 'llvm-ar',
|
|
platform: platform,
|
|
config: config,
|
|
);
|
|
}
|
|
|
|
String? getNdkLdPath({Platform? platform, Config? config}) {
|
|
platform ??= globals.platform;
|
|
return getNdkBinaryPath(
|
|
platform.isWindows ? 'ld.lld.exe' : 'ld.lld',
|
|
platform: platform,
|
|
config: config,
|
|
);
|
|
}
|
|
|
|
/// Sets up various paths used internally.
|
|
///
|
|
/// This method should be called in a case where the tooling may have updated
|
|
/// SDK artifacts, such as after running a gradle build.
|
|
void reinitialize({FileSystem? fileSystem}) {
|
|
List<Version> buildTools = <Version>[]; // 19.1.0, 22.0.1, ...
|
|
|
|
final Directory buildToolsDir = directory.childDirectory('build-tools');
|
|
if (buildToolsDir.existsSync()) {
|
|
buildTools =
|
|
buildToolsDir
|
|
.listSync()
|
|
.map((FileSystemEntity entity) {
|
|
try {
|
|
return Version.parse(entity.basename);
|
|
} on Exception {
|
|
return null;
|
|
}
|
|
})
|
|
.whereType<Version>()
|
|
.toList();
|
|
}
|
|
|
|
// Match up platforms with the best corresponding build-tools.
|
|
_sdkVersions =
|
|
_platforms
|
|
.map<AndroidSdkVersion?>((Directory platformDir) {
|
|
final String platformName = platformDir.basename;
|
|
int platformVersion;
|
|
|
|
try {
|
|
final Match? numberedVersion = _numberedAndroidPlatformRe.firstMatch(platformName);
|
|
if (numberedVersion != null) {
|
|
platformVersion = int.parse(numberedVersion.group(1)!);
|
|
} else {
|
|
final String buildProps = platformDir.childFile('build.prop').readAsStringSync();
|
|
final Iterable<Match> versionMatches =
|
|
const LineSplitter()
|
|
.convert(buildProps)
|
|
.map<RegExpMatch?>(_sdkVersionRe.firstMatch)
|
|
.whereType<Match>();
|
|
|
|
if (versionMatches.isEmpty) {
|
|
return null;
|
|
}
|
|
|
|
final String? versionString = versionMatches.first.group(1);
|
|
if (versionString == null) {
|
|
return null;
|
|
}
|
|
platformVersion = int.parse(versionString);
|
|
}
|
|
} on Exception {
|
|
return null;
|
|
}
|
|
|
|
Version? buildToolsVersion = Version.primary(
|
|
buildTools.where((Version version) {
|
|
return version.major == platformVersion;
|
|
}).toList(),
|
|
);
|
|
|
|
buildToolsVersion ??= Version.primary(buildTools);
|
|
|
|
if (buildToolsVersion == null) {
|
|
return null;
|
|
}
|
|
|
|
return AndroidSdkVersion._(
|
|
this,
|
|
sdkLevel: platformVersion,
|
|
platformName: platformName,
|
|
buildToolsVersion: buildToolsVersion,
|
|
fileSystem: fileSystem ?? globals.fs,
|
|
);
|
|
})
|
|
.whereType<AndroidSdkVersion>()
|
|
.toList();
|
|
|
|
_sdkVersions.sort();
|
|
|
|
_latestVersion = _sdkVersions.isEmpty ? null : _sdkVersions.last;
|
|
}
|
|
|
|
/// Returns the filesystem path of the Android SDK manager tool.
|
|
String? get sdkManagerPath {
|
|
final String executable = globals.platform.isWindows ? 'sdkmanager.bat' : 'sdkmanager';
|
|
return getCmdlineToolsPath(executable, skipOldTools: true);
|
|
}
|
|
|
|
/// Returns the version of the Android SDK manager tool or null if not found.
|
|
String? get sdkManagerVersion {
|
|
if (sdkManagerPath == null || !globals.processManager.canRun(sdkManagerPath)) {
|
|
throwToolExit(
|
|
'Android sdkmanager not found. Update to the latest Android SDK and ensure that '
|
|
'the cmdline-tools are installed to resolve this.',
|
|
);
|
|
}
|
|
final RunResult result = globals.processUtils.runSync(<String>[
|
|
sdkManagerPath!,
|
|
'--version',
|
|
], environment: _java?.environment);
|
|
if (result.exitCode != 0) {
|
|
globals.printTrace(
|
|
'sdkmanager --version failed: exitCode: ${result.exitCode} stdout: ${result.stdout} stderr: ${result.stderr}',
|
|
);
|
|
return null;
|
|
}
|
|
return result.stdout.trim();
|
|
}
|
|
|
|
@override
|
|
String toString() => 'AndroidSdk: $directory';
|
|
}
|
|
|
|
class AndroidSdkVersion implements Comparable<AndroidSdkVersion> {
|
|
AndroidSdkVersion._(
|
|
this.sdk, {
|
|
required this.sdkLevel,
|
|
required this.platformName,
|
|
required this.buildToolsVersion,
|
|
required FileSystem fileSystem,
|
|
}) : _fileSystem = fileSystem;
|
|
|
|
final AndroidSdk sdk;
|
|
final int sdkLevel;
|
|
final String platformName;
|
|
final Version buildToolsVersion;
|
|
|
|
final FileSystem _fileSystem;
|
|
|
|
String get buildToolsVersionName => buildToolsVersion.toString();
|
|
|
|
String get androidJarPath => getPlatformsPath('android.jar');
|
|
|
|
/// Return the path to the android application package tool.
|
|
///
|
|
/// This is used to dump the xml in order to launch built android applications.
|
|
///
|
|
/// See also:
|
|
/// * [AndroidApk.fromApk], which depends on this to determine application identifiers.
|
|
String get aaptPath => getBuildToolsPath('aapt');
|
|
|
|
List<String> validateSdkWellFormed() {
|
|
final String? existsAndroidJarPath = _exists(androidJarPath);
|
|
if (existsAndroidJarPath != null) {
|
|
return <String>[existsAndroidJarPath];
|
|
}
|
|
|
|
final String? canRunAaptPath = _canRun(aaptPath);
|
|
if (canRunAaptPath != null) {
|
|
return <String>[canRunAaptPath];
|
|
}
|
|
|
|
return <String>[];
|
|
}
|
|
|
|
String getPlatformsPath(String itemName) {
|
|
return sdk.directory
|
|
.childDirectory('platforms')
|
|
.childDirectory(platformName)
|
|
.childFile(itemName)
|
|
.path;
|
|
}
|
|
|
|
String getBuildToolsPath(String binaryName) {
|
|
return sdk.directory
|
|
.childDirectory('build-tools')
|
|
.childDirectory(buildToolsVersionName)
|
|
.childFile(binaryName)
|
|
.path;
|
|
}
|
|
|
|
@override
|
|
int compareTo(AndroidSdkVersion other) => sdkLevel - other.sdkLevel;
|
|
|
|
@override
|
|
String toString() =>
|
|
'[${sdk.directory}, SDK version $sdkLevel, build-tools $buildToolsVersionName]';
|
|
|
|
String? _exists(String path) {
|
|
if (!_fileSystem.isFileSync(path)) {
|
|
return 'Android SDK file not found: $path.';
|
|
}
|
|
return null;
|
|
}
|
|
|
|
String? _canRun(String path) {
|
|
if (!globals.processManager.canRun(path)) {
|
|
return 'Android SDK file not found: $path.';
|
|
}
|
|
return null;
|
|
}
|
|
}
|