feature: Initial commit

Author: hacker1024

.gitignore

@@ -0,0 +1,10 @@
+# Files and directories created by pub.
+.dart_tool/
+.packages
+
+# Conventional directory for build outputs.
+build/
+
+# Omit committing pubspec.lock for library packages; see
+# https://dart.dev/guides/libraries/private-files#pubspeclock.
+pubspec.lock

CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0
+
+- Initial version.

README.md

@@ -0,0 +1,59 @@
+# gibadb
+A tool to easily install the Android SDK command-line and platform tools.
+
+**For developers:**
+_This README describes the CLI tool that ships with this Dart package. For package
+documentation, consult the appropriate [README](README_PACKAGE.md)._
+
+## Features
+- [x] Cross-platform support
+  - [x] Windows
+  - [x] MacOS
+  - [x] Linux
+- [x] Upgradeable platform tools
+- [x] Minimal, but a standard SDK installation (Android Studio compatible)
+
+## Obtaining
+Binaries can be found in the [releases](https://github.com/hacker1024/gibadb/releases) page.
+
+<details>
+<summary>
+Alternatively, for those with the Dart SDK installed, pub can be used to activate
+the package...
+</summary>
+
+```
+$ dart pub global activate --source git https://github.com/hacker1024/gibadb.git
+```
+</details>
+
+The following external tools are required:
+
+- Java
+- p7zip or `unzip` (macOS and Linux)
+- PowerShell 5.0+ (Windows)
+
+## Usage
+
+1. Open a terminal (or command prompt)
+2. Run `gibadb`
+3. Add the required lines to your PATH
+
+### Options
+
+```
+$ gibadb --help
+
+Usage: gibadb.dart [options] [SDK installation directory]
+Install the Android SDK command-line and platform tools.
+
+If no SDK installation directory is provided, a common, platform-specific location is chosen.
+-v, --verbose                                 Show more installation details.
+    --[no-]launch-path-settings               Open the system path settings after installation.
+                                              (defaults to on)
+    --[no-]platform-tools                     Install the SDK platform tools as well as the base SDK command-line tools.
+                                              (defaults to on)
+-a, --archive=<command-line tools archive>    Use an existing SDK command-line tools archive, instead of downloading one.
+    --keep-archive                            Don't delete the SDK command-line tools archive.
+-h, --help                                    Show the usage information.
+```

README_PACKAGE.md

@@ -0,0 +1,5 @@
+# android_platform_tools_installer_ui
+_An embeddable UI to install the Android SDK Command-Line Tools and Platform Tools._
+
+## Usage
+See the [`gibadb`](bin/gibadb.dart) script for example usage.

analysis_options.yaml

@@ -0,0 +1 @@
+include: package:lint/analysis_options_package.yaml

bin/gibadb.dart

@@ -0,0 +1,150 @@
+import 'dart:io';
+
+import 'package:adb_tools/adb_tools.dart';
+import 'package:android_platform_tools_installer_ui/android_platform_tools_installer_ui.dart';
+import 'package:args/args.dart';
+
+Future<void> main(List<String> arguments) async {
+  final argParser = ArgParser()
+    ..addFlag(
+      'verbose',
+      abbr: 'v',
+      help: 'Show more installation details.',
+      negatable: false,
+    )
+    ..addFlag(
+      'launch-path-settings',
+      help: 'Open the system path settings after installation.',
+      defaultsTo: true,
+    )
+    ..addFlag(
+      'platform-tools',
+      help:
+          'Install the SDK platform tools as well as the base SDK command-line tools.',
+      defaultsTo: true,
+    )
+    ..addOption(
+      'archive',
+      abbr: 'a',
+      help:
+          'Use an existing SDK command-line tools archive, instead of downloading one.',
+      valueHelp: 'command-line tools archive',
+    )
+    ..addFlag(
+      'keep-archive',
+      help: "Don't delete the SDK command-line tools archive.",
+      negatable: false,
+    )
+    ..addFlag(
+      'help',
+      abbr: 'h',
+      help: 'Show the usage information.',
+      negatable: false,
+    );
+
+  void printUsage(StringSink output) {
+    output
+      ..writeln(
+        'Usage: ${Platform.script.pathSegments.last} [options] [SDK installation directory]',
+      )
+      ..writeln('Install the Android SDK command-line and platform tools.')
+      ..writeln()
+      ..writeln(
+        'If no SDK installation directory is provided, a common, platform-specific location is chosen.',
+      )
+      ..writeln(argParser.usage);
+  }
+
+  final ArgResults argResults;
+  try {
+    argResults = argParser.parse(arguments);
+  } on FormatException catch (e) {
+    stderr
+      ..writeln(e.message)
+      ..writeln();
+    printUsage(stderr);
+    exitCode = 2;
+    return;
+  }
+
+  final verbose = argResults['verbose']! as bool;
+  final launchPathSettings = argResults['launch-path-settings']! as bool;
+  final installPlatformTools = argResults['platform-tools']! as bool;
+  final existingCmdlineToolsArchive = argResults['archive'] as String?;
+  final keepCmdlineToolsArchive = argResults['keep-archive']! as bool;
+  final showUsageInformation = argResults['help']! as bool;
+  final sdkInstallationDirectoryPath =
+      argResults.rest.isEmpty ? null : argResults.rest[0];
+
+  if (showUsageInformation) {
+    printUsage(stdout);
+    return;
+  }
+
+  final File? existingArchiveFile;
+  if (existingCmdlineToolsArchive != null) {
+    existingArchiveFile = File(existingCmdlineToolsArchive);
+    if (!existingArchiveFile.existsSync()) {
+      stderr.writeln(
+          'The specified commandline-tools archive file does not exist.');
+      exitCode = -1;
+      return;
+    }
+  } else {
+    existingArchiveFile = null;
+  }
+
+  final Directory? sdkRoot;
+  if (sdkInstallationDirectoryPath != null) {
+    sdkRoot = Directory(sdkInstallationDirectoryPath);
+    if (!sdkRoot.parent.existsSync()) {
+      stderr.writeln(
+          'The specified SDK installation parent directory does not exist.');
+      exitCode = -1;
+      return;
+    }
+    sdkRoot.createSync();
+  } else {
+    sdkRoot = null;
+  }
+
+  String formatMessage(String message, {required bool isError}) =>
+      '${isError ? '!' : '*'} $message';
+  void writeMessage(String message) =>
+      stdout.writeln(formatMessage(message, isError: false));
+  void writeError(String message) =>
+      stderr.writeln(formatMessage(message, isError: true));
+
+  try {
+    await installAndroidSdk(
+      sdkRoot: sdkRoot,
+      existingArchiveFile: existingArchiveFile,
+      deleteArchiveFile: !keepCmdlineToolsArchive,
+      launchPathSettings: launchPathSettings,
+      verbose: verbose,
+      messageFormatter: formatMessage,
+      installPlatformTools: installPlatformTools,
+    );
+  } on CmdlineToolsInstallUnsupportedPlatformException {
+    writeError('Could not install command-line tools: Unsupported platform!');
+    exitCode = -2;
+    return;
+  } on CmdlineToolsExtractFailedException catch (e) {
+    writeError('Could not extract command-line tools: error ${e.errorCode}');
+    exitCode = -3;
+    return;
+  } on CmdlineToolsPrepareFailedException catch (e) {
+    writeError('Could not prepare command-line tools.');
+    writeError(
+      e.fileSystemException
+          .toString()
+          .substring('FileSystemException: '.length),
+    );
+    exitCode = -4;
+    return;
+  } on PlatformToolsInstallFailedException catch (e) {
+    writeError('Could not install platform tools: error ${e.errorCode}');
+    exitCode = -5;
+    return;
+  }
+}

lib/android_platform_tools_installer_ui.dart

@@ -0,0 +1,3 @@
+library android_platform_tools_installer_ui;
+
+export 'src/android_platform_tools_installer_ui.dart';

lib/src/android_platform_tools_installer_ui.dart

@@ -0,0 +1,154 @@
+import 'dart:async';
+import 'dart:io';
+
+import 'package:adb_tools/adb_tools.dart';
+import 'package:path/path.dart';
+import 'package:progressbar2/progressbar2.dart';
+
+/// Installs the Android SDK, and, if [installPlatformTools] is true, the SDK
+/// platform tools, to the given [sdkRoot] directory.
+///
+/// Returns a [Future] that completes when the installation finishes.
+///
+/// If [output] is given, messages will be logged to it. Otherwise, standard I/O
+/// will be used. If standard I/O is used, subprocess output will not be
+/// streamed as messages and will instead be sent directly to standard output.
+/// If an [existingArchiveFile] is provided, it will be used instead of
+/// downloading the latest one available.
+/// If [deleteArchiveFile] is true, the downloaded SDK archive file will be
+/// deleted as soon as it is no longer needed.
+/// If a [messageFormatter] is provided, messages will be sent through it before
+/// being outputted.
+/// If [verbose] is true, subprocess will be run with verbose flags, and
+/// output from more subprocesses will be shown. Note that the latter cannot be
+/// prevented at all when no [output] sink is provided, even if [verbose] is
+/// false.
+///
+/// [launchPathSettings] and [installPlatformTools] are passed directly to
+/// [installCmdlineTools].
+///
+/// This function relies on the same external tools as [installCmdlineTools].
+Future<void> installAndroidSdk({
+  StringSink? output,
+  Directory? sdkRoot,
+  File? existingArchiveFile,
+  bool deleteArchiveFile = true,
+  bool launchPathSettings = true,
+  bool verbose = false,
+  String Function(String message, {required bool isError}) messageFormatter =
+      _unitMessageFormatter,
+  bool installPlatformTools = true,
+}) async {
+  // Set up output channels.
+  final messageSink = output ?? stdout;
+  final errorSink = output ?? stderr;
+  void writeMessage(String message) =>
+      messageSink.writeln(messageFormatter(message, isError: false));
+  void writeError(String message) =>
+      errorSink.writeln(messageFormatter(message, isError: true));
+
+  // Use the provided SDK root, or determine a platform-appropriate one if none
+  // is provided.
+  sdkRoot ??= _determineSdkRoot();
+
+  // Download the command-line tools archive if required, using a pretty
+  // progress bar if outputting to a terminal.
+  final File archiveFile;
+  if (existingArchiveFile == null) {
+    final ProgressCallback onReceiveProgress;
+    if (output == null && stdout.hasTerminal) {
+      writeMessage('Downloading SDK command-line tools:');
+      final progressBar = ProgressBar(
+        formatter: (current, total, progress, elapsed) =>
+            '[$current/$total] ${ProgressBar.formatterBarToken} [${(progress * 100).floor()}%]',
+        total: 0,
+      );
+      onReceiveProgress = (count, total) {
+        progressBar.total = total;
+        progressBar.value = count;
+        progressBar.render();
+      };
+    } else {
+      String format(int count, int total) =>
+          'Downloading SDK command-line tools: $count/$total (${((count / total) * 100).floor()}%)';
+      onReceiveProgress = output == null
+          ? (count, total) => writeMessage(format(count, total))
+          : (count, total) => writeMessage(format(count, total));
+    }
+    archiveFile = await downloadCmdlineToolsArchive(
+      sdkRoot,
+      onReceiveProgress: onReceiveProgress,
+    );
+  } else {
+    archiveFile = existingArchiveFile;
+  }
+
+  late final List<Directory> pathEntries;
+  Type? currentProgressStage;
+  await for (final progress in installCmdlineTools(
+    sdkRoot,
+    archiveFile,
+    deleteArchiveFile: deleteArchiveFile,
+    launchPathSettings: launchPathSettings,
+    verbose: verbose,
+    installPlatformTools: installPlatformTools,
+    inheritStdio: output == null,
+  )) {
+    final isNewProgressStage = progress.runtimeType != currentProgressStage;
+    if (isNewProgressStage) currentProgressStage = progress.runtimeType;
+    final bool messageIsVerbose;
+
+    if (progress is CmdlineToolsInstallExtracting) {
+      if (isNewProgressStage) {
+        writeMessage('Extracting SDK tools...');
+      }
+      if (!progress.usingNativeUnzip) {
+        writeError('Could not use native unzip tool');
+      }
+      messageIsVerbose = true; // Classify extraction output as verbose.
+    } else if (progress is CmdlineToolsInstallInstallingPlatformTools) {
+      if (isNewProgressStage) {
+        writeMessage('Installing platform tools...');
+      }
+      messageIsVerbose = false;
+    } else if (progress is CmdlineToolsInstallCompleted) {
+      pathEntries = progress.directPathEntries.toList(growable: false);
+      messageIsVerbose = false;
+    } else {
+      messageIsVerbose = false;
+    }
+
+    final message = progress.message;
+    if (message != null && (verbose || !messageIsVerbose)) {
+      message.isError ? writeError(message.text) : writeMessage(message.text);
+    }
+  }
+
+  writeMessage(
+    'Android SDK installed. Remember to add the following directories to your PATH:',
+  );
+  for (final path in pathEntries) {
+    messageSink.write('  ');
+    messageSink.writeln(path.path);
+  }
+}
+
+Directory _determineSdkRoot() {
+  final Directory sdkRoot;
+  if (Platform.isMacOS) {
+    sdkRoot = Directory(
+        join(Platform.environment['HOME']!, 'Library', 'Android', 'Sdk'));
+  } else if (Platform.isLinux) {
+    sdkRoot = Directory(join(Platform.environment['HOME']!, 'Android', 'Sdk'));
+  } else if (Platform.isWindows) {
+    sdkRoot = Directory(
+        join(Platform.environment['LOCALAPPDATA']!, 'Android', 'Sdk'));
+  } else {
+    throw const CmdlineToolsInstallUnsupportedPlatformException();
+  }
+  sdkRoot.createSync(recursive: true);
+  return sdkRoot;
+}
+
+String _unitMessageFormatter(String message, {required bool isError}) =>
+    message;