packages/flutter_tools/lib/src/android/android_sdk.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.

/// @docImport 'application_package.dart';
library;

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 kAndroidSdkRoot = 'ANDROID_SDK_ROOT';
const 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 kAndroidNdkHome = 'ANDROID_NDK_HOME';
const kAndroidNdkPath = 'ANDROID_NDK_PATH';
const kAndroidNdkRoot = 'ANDROID_NDK_ROOT';

final _numberedAndroidPlatformRe = RegExp(r'^android-([0-9]+)$');
final _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;

  var _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 (var 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 (var 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 searchPaths = <String>[
      ?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 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 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()];
    }

    if (directory.absolute.path.contains(' ')) {
      final androidSdkSpaceWarning =
          'Android SDK location currently '
          'contains spaces, which is not supported by the Android SDK as it '
          'causes problems with NDK tools. Try moving it from '
          '${directory.absolute.path} to a path without spaces.';
      return <String>[androidSdkSpaceWarning];
    }

    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 binaryName = globals.platform.isWindows ? 'emulator.exe' : 'emulator';
    // Emulator now lives inside "emulator" but used to live inside "tools" so
    // try both.
    final searchFolders = <String>['emulator', 'tools'];
    for (final 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 _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}) {
    var 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 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;
  }
}