[native_toolchain_c] Consider ANDROID_HOME environment variable

pkgs/native_toolchain_c/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.17.3-wip
+
+- Search for NDK in `ANDROID_HOME` and `ANDROID_NDK` environment variables.
+
 ## 0.17.2
 
 - Made `CBuilder.run` `Logger` argument optional. It now defaults to a logger

pkgs/native_toolchain_c/lib/src/cbuilder/compiler_resolver.dart

@@ -16,6 +16,7 @@ import '../native_toolchain/recognizer.dart';
 import '../tool/tool.dart';
 import '../tool/tool_error.dart';
 import '../tool/tool_instance.dart';
+import '../tool/tool_resolver.dart';
 import '../utils/env_from_bat.dart';
 
 // TODO(dacoharkes): This should support alternatives.
@@ -25,14 +26,16 @@ class CompilerResolver {
   final Logger? logger;
   final OS hostOS;
   final Architecture hostArchitecture;
+  final ToolResolvingContext context;
 
   CompilerResolver({
     required this.codeConfig,
     required this.logger,
     OS? hostOS, // Only visible for testing.
     Architecture? hostArchitecture, // Only visible for testing.
   }) : hostOS = hostOS ?? OS.current,
-       hostArchitecture = hostArchitecture ?? Architecture.current;
+       hostArchitecture = hostArchitecture ?? Architecture.current,
+       context = ToolResolvingContext(logger: logger);
 
   Future<ToolInstance> resolveCompiler() async {
     // First, check if the launcher provided a direct path to the compiler.
@@ -96,17 +99,15 @@ class CompilerResolver {
         'Using compiler ${inputCcUri.toFilePath()} '
         'from BuildInput.cCompiler.cc.',
       );
-      return (await CompilerRecognizer(
-        inputCcUri,
-      ).resolve(logger: logger)).first;
+      return (await CompilerRecognizer(inputCcUri).resolve(context)).first;
     }
     logger?.finer('No compiler set in BuildInput.cCompiler.cc.');
     return null;
   }
 
   Future<ToolInstance?> _tryLoadToolFromNativeToolchain(Tool tool) async {
     final resolved = (await tool.defaultResolver!.resolve(
-      logger: logger,
+      context,
     )).where((i) => i.tool == tool).toList()..sort();
     return resolved.isEmpty ? null : resolved.first;
   }
@@ -183,9 +184,7 @@ class CompilerResolver {
         'Using archiver ${inputArUri.toFilePath()} '
         'from BuildInput.cCompiler.ar.',
       );
-      return (await ArchiverRecognizer(
-        inputArUri,
-      ).resolve(logger: logger)).first;
+      return (await ArchiverRecognizer(inputArUri).resolve(context)).first;
     }
     logger?.finer('No archiver set in BuildInput.cCompiler.ar.');
     return null;
@@ -221,7 +220,7 @@ class CompilerResolver {
     }
     final vcvarsScript = (await vcvars(
       compiler,
-    ).defaultResolver!.resolve(logger: logger)).first;
+    ).defaultResolver!.resolve(context)).first;
     return await environmentFromBatchFile(
       vcvarsScript.uri,
       arguments: [

pkgs/native_toolchain_c/lib/src/cbuilder/run_cbuilder.dart

@@ -12,6 +12,7 @@ import '../native_toolchain/msvc.dart';
 import '../native_toolchain/tool_likeness.dart';
 import '../native_toolchain/xcode.dart';
 import '../tool/tool_instance.dart';
+import '../tool/tool_resolver.dart';
 import '../utils/run_process.dart';
 import 'compiler_resolver.dart';
 import 'language.dart';
@@ -96,21 +97,21 @@ class RunCBuilder {
 
   Future<Uri> archiver() async => (await _resolver.resolveArchiver()).uri;
 
-  Future<Uri> iosSdk(IOSSdk iosSdk, {required Logger? logger}) async {
+  Future<Uri> iosSdk(IOSSdk iosSdk, ToolResolvingContext context) async {
     if (iosSdk == IOSSdk.iPhoneOS) {
       return (await iPhoneOSSdk.defaultResolver!.resolve(
-        logger: logger,
+        context,
       )).where((i) => i.tool == iPhoneOSSdk).first.uri;
     }
     assert(iosSdk == IOSSdk.iPhoneSimulator);
     return (await iPhoneSimulatorSdk.defaultResolver!.resolve(
-      logger: logger,
+      context,
     )).where((i) => i.tool == iPhoneSimulatorSdk).first.uri;
   }
 
-  Future<Uri> macosSdk({required Logger? logger}) async =>
+  Future<Uri> macosSdk(ToolResolvingContext context) async =>
       (await macosxSdk.defaultResolver!.resolve(
-        logger: logger,
+        context,
       )).where((i) => i.tool == macosxSdk).first.uri;
 
   Uri androidSysroot(ToolInstance compiler) =>
@@ -224,6 +225,8 @@ class RunCBuilder {
     Uri? outFile,
     Map<String, String> environment,
   ) async {
+    final context = ToolResolvingContext(logger: logger);
+
     await runProcess(
       executable: toolInstance.uri,
       environment: environment,
@@ -245,11 +248,11 @@ class RunCBuilder {
           '-mmacos-version-min=$targetMacOSVersion',
         if (codeConfig.targetOS == OS.iOS) ...[
           '-isysroot',
-          (await iosSdk(targetIosSdk!, logger: logger)).toFilePath(),
+          (await iosSdk(targetIosSdk!, context)).toFilePath(),
         ],
         if (codeConfig.targetOS == OS.macOS) ...[
           '-isysroot',
-          (await macosSdk(logger: logger)).toFilePath(),
+          (await macosSdk(context)).toFilePath(),
         ],
         if (installName != null) ...[
           '-install_name',

pkgs/native_toolchain_c/lib/src/native_toolchain/android_ndk.dart

@@ -6,6 +6,7 @@ import 'dart:io';
 
 import 'package:code_assets/code_assets.dart';
 import 'package:logging/logging.dart';
+import 'package:path/path.dart' as p;
 
 import '../tool/tool.dart';
 import '../tool/tool_instance.dart';
@@ -36,41 +37,51 @@ final androidNdkLld = Tool(
 );
 
 class _AndroidNdkResolver implements ToolResolver {
-  final installLocationResolver = PathVersionResolver(
-    wrappedResolver: ToolResolvers([
-      RelativeToolResolver(
-        toolName: 'Android NDK',
-        wrappedResolver: PathToolResolver(
-          toolName: 'ndk-build',
-          executableName: Platform.isWindows ? 'ndk-build.cmd' : 'ndk-build',
-        ),
-        relativePath: Uri(path: ''),
-      ),
-      InstallLocationResolver(
-        toolName: 'Android NDK',
-        paths: [
-          if (Platform.isLinux) ...[
-            '\$HOME/.androidsdkroot/ndk/*/', // Firebase Studio
-            '\$HOME/Android/Sdk/ndk/*/',
-            '\$HOME/Android/Sdk/ndk-bundle/',
-          ],
-          if (Platform.isMacOS) ...['\$HOME/Library/Android/sdk/ndk/*/'],
-          if (Platform.isWindows) ...[
-            '\$HOME/AppData/Local/Android/Sdk/ndk/*/',
-          ],
-        ],
-      ),
-    ]),
-  );
+  ToolResolver installLocationResolver(ToolResolvingContext context) =>
+      PathVersionResolver(
+        wrappedResolver: ToolResolvers([
+          RelativeToolResolver(
+            toolName: 'Android NDK',
+            wrappedResolver: PathToolResolver(
+              toolName: 'ndk-build',
+              executableName: Platform.isWindows
+                  ? 'ndk-build.cmd'
+                  : 'ndk-build',
+            ),
+            relativePath: Uri(path: ''),
+          ),
+          InstallLocationResolver(
+            toolName: 'Android NDK',
+            paths: [
+              if (context.environment['ANDROID_HOME'] case final androidHome?)
+                p.join(androidHome, 'ndk/*/'),
+              for (final ndkHomeKey in _ndkHomeEnvironmentVariables)
+                if (context.environment[ndkHomeKey] case final home?) home,
+
+              if (Platform.isLinux) ...[
+                '\$HOME/.androidsdkroot/ndk/*/', // Firebase Studio
+                '\$HOME/Android/Sdk/ndk/*/',
+                '\$HOME/Android/Sdk/ndk-bundle/',
+              ],
+              if (Platform.isMacOS) ...['\$HOME/Library/Android/sdk/ndk/*/'],
+              if (Platform.isWindows) ...[
+                '\$HOME/AppData/Local/Android/Sdk/ndk/*/',
+              ],
+            ],
+          ),
+        ]),
+      );
 
   @override
-  Future<List<ToolInstance>> resolve({required Logger? logger}) async {
-    final ndkInstances = await installLocationResolver.resolve(logger: logger);
+  Future<List<ToolInstance>> resolve(ToolResolvingContext context) async {
+    final ndkInstances = await installLocationResolver(
+      context,
+    ).resolve(context);
 
     return [
       for (final ndkInstance in ndkInstances) ...[
         ndkInstance,
-        ...await tryResolveClang(ndkInstance, logger: logger),
+        ...await tryResolveClang(ndkInstance, logger: context.logger),
       ],
     ];
   }
@@ -127,4 +138,12 @@ class _AndroidNdkResolver implements ToolResolver {
     }
     return result;
   }
+
+  static const _ndkHomeEnvironmentVariables = [
+    // https://github.com/actions/runner-images/blob/main/images/ubuntu/Ubuntu2404-Readme.md#environment-variables-2
+    'ANDROID_NDK',
+    'ANDROID_NDK_HOME',
+    'ANDROID_NDK_LATEST_HOME',
+    'ANDROID_NDK_ROOT',
+  ];
 }

pkgs/native_toolchain_c/lib/src/native_toolchain/msvc.dart

@@ -258,10 +258,9 @@ Tool _msvcTool({
 
 class VisualStudioResolver implements ToolResolver {
   @override
-  Future<List<ToolInstance>> resolve({required Logger? logger}) async {
-    final vswhereInstances = await vswhere.defaultResolver!.resolve(
-      logger: logger,
-    );
+  Future<List<ToolInstance>> resolve(ToolResolvingContext context) async {
+    final vswhereInstances = await vswhere.defaultResolver!.resolve(context);
+    final logger = context.logger;
 
     final result = <ToolInstance>[];
     for (final vswhereInstance in vswhereInstances.take(1)) {

pkgs/native_toolchain_c/lib/src/native_toolchain/recognizer.dart

@@ -3,7 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:code_assets/code_assets.dart';
-import 'package:logging/logging.dart';
 
 import '../tool/tool.dart';
 import '../tool/tool_instance.dart';
@@ -19,7 +18,8 @@ class CompilerRecognizer implements ToolResolver {
   CompilerRecognizer(this.uri);
 
   @override
-  Future<List<ToolInstance>> resolve({required Logger? logger}) async {
+  Future<List<ToolInstance>> resolve(ToolResolvingContext context) async {
+    final logger = context.logger;
     final os = OS.current;
     logger?.finer('Trying to recognize $uri.');
     final filePath = uri.toFilePath();
@@ -64,7 +64,8 @@ class LinkerRecognizer implements ToolResolver {
   LinkerRecognizer(this.uri);
 
   @override
-  Future<List<ToolInstance>> resolve({required Logger? logger}) async {
+  Future<List<ToolInstance>> resolve(ToolResolvingContext context) async {
+    final logger = context.logger;
     final os = OS.current;
     logger?.finer('Trying to recognize $uri.');
     final filePath = uri.toFilePath();
@@ -111,7 +112,8 @@ class ArchiverRecognizer implements ToolResolver {
   ArchiverRecognizer(this.uri);
 
   @override
-  Future<List<ToolInstance>> resolve({required Logger? logger}) async {
+  Future<List<ToolInstance>> resolve(ToolResolvingContext context) async {
+    final logger = context.logger;
     logger?.finer('Trying to recognize $uri.');
     final os = OS.current;
     final filePath = uri.toFilePath();

pkgs/native_toolchain_c/lib/src/native_toolchain/xcode.dart

@@ -44,28 +44,28 @@ final Tool iPhoneSimulatorSdk = Tool(
 
 class XCodeSdkResolver implements ToolResolver {
   @override
-  Future<List<ToolInstance>> resolve({required Logger? logger}) async {
-    final xcrunInstances = await xcrun.defaultResolver!.resolve(logger: logger);
+  Future<List<ToolInstance>> resolve(ToolResolvingContext context) async {
+    final xcrunInstances = await xcrun.defaultResolver!.resolve(context);
 
     return [
       for (final xcrunInstance in xcrunInstances) ...[
         ...await tryResolveSdk(
           xcrunInstance: xcrunInstance,
           sdk: 'macosx',
           tool: macosxSdk,
-          logger: logger,
+          logger: context.logger,
         ),
         ...await tryResolveSdk(
           xcrunInstance: xcrunInstance,
           sdk: 'iphoneos',
           tool: iPhoneOSSdk,
-          logger: logger,
+          logger: context.logger,
         ),
         ...await tryResolveSdk(
           xcrunInstance: xcrunInstance,
           sdk: 'iphonesimulator',
           tool: iPhoneSimulatorSdk,
-          logger: logger,
+          logger: context.logger,
         ),
       ],
       // xcrun --sdk macosx --show-sdk-path)