Simplify AdbRunner constructor: require full adb path

Address review feedback (threads 41-43): replace Func<string?> getSdkPath
constructor with string adbPath that takes the full path to the adb
executable. Remove AdbPath property, IsAvailable property, RequireAdb(),
PATH discovery fallback, and getSdkPath/getJdkPath fields.

Callers are now responsible for resolving the adb path before constructing.
Environment variables can optionally be passed via the constructor.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: rmarinho

src/Xamarin.Android.Tools.AndroidSdk/Runners/AdbRunner.cs

@@ -6,7 +6,6 @@
 using System.Diagnostics;
 using System.Globalization;
 using System.IO;
-using System.Linq;
 using System.Net.Sockets;
 using System.Text.RegularExpressions;
 using System.Threading;
@@ -20,52 +19,28 @@ namespace Xamarin.Android.Tools;
 /// </summary>
 public class AdbRunner
 {
-	readonly Func<string?> getSdkPath;
-	readonly Func<string?>? getJdkPath;
+	readonly string adbPath;
+	readonly IDictionary<string, string>? environmentVariables;
 
 	// Pattern to match device lines: <serial> <state> [key:value ...]
-	// Requires 2+ spaces between serial and state (adb pads serials).
-	// Matches known adb device states. Uses \s+ to handle both space and tab separators.
+	// Uses \s+ to handle both space and tab separators.
 	// Explicit state list prevents false positives from non-device lines.
 	static readonly Regex AdbDevicesRegex = new Regex (
 		@"^([^\s]+)\s+(device|offline|unauthorized|authorizing|no permissions|recovery|sideload|bootloader|connecting|host)\s*(.*)$",
 		RegexOptions.Compiled | RegexOptions.IgnoreCase);
 	static readonly Regex ApiRegex = new Regex (@"\bApi\b", RegexOptions.Compiled);
 
-	public AdbRunner (Func<string?> getSdkPath)
-		: this (getSdkPath, null)
-	{
-	}
-
-	public AdbRunner (Func<string?> getSdkPath, Func<string?>? getJdkPath)
-	{
-		this.getSdkPath = getSdkPath ?? throw new ArgumentNullException (nameof (getSdkPath));
-		this.getJdkPath = getJdkPath;
-	}
-
-	public string? AdbPath {
-		get {
-			var sdkPath = getSdkPath ();
-			if (!string.IsNullOrEmpty (sdkPath)) {
-				var ext = OS.IsWindows ? ".exe" : "";
-				var sdkAdb = Path.Combine (sdkPath, "platform-tools", "adb" + ext);
-				if (File.Exists (sdkAdb))
-					return sdkAdb;
-			}
-			return ProcessUtils.FindExecutablesInPath ("adb").FirstOrDefault ();
-		}
-	}
-
-	public bool IsAvailable => AdbPath is not null;
-
-	string RequireAdb ()
-	{
-		return AdbPath ?? throw new InvalidOperationException ("ADB not found.");
-	}
-
-	IDictionary<string, string> GetEnvironmentVariables ()
+	/// <summary>
+	/// Creates a new AdbRunner with the full path to the adb executable.
+	/// </summary>
+	/// <param name="adbPath">Full path to the adb executable (e.g., "/path/to/sdk/platform-tools/adb").</param>
+	/// <param name="environmentVariables">Optional environment variables to pass to adb processes.</param>
+	public AdbRunner (string adbPath, IDictionary<string, string>? environmentVariables = null)
 	{
-		return AndroidEnvironmentHelper.GetEnvironmentVariables (getSdkPath (), getJdkPath?.Invoke ());
+		if (string.IsNullOrWhiteSpace (adbPath))
+			throw new ArgumentException ("Path to adb must not be empty.", nameof (adbPath));
+		this.adbPath = adbPath;
+		this.environmentVariables = environmentVariables;
 	}
 
 	/// <summary>
@@ -74,12 +49,10 @@ IDictionary<string, string> GetEnvironmentVariables ()
 	/// </summary>
 	public async Task<IReadOnlyList<AdbDeviceInfo>> ListDevicesAsync (CancellationToken cancellationToken = default)
 	{
-		var adb = RequireAdb ();
-		var envVars = GetEnvironmentVariables ();
 		using var stdout = new StringWriter ();
 		using var stderr = new StringWriter ();
-		var psi = ProcessUtils.CreateProcessStartInfo (adb, "devices", "-l");
-		var exitCode = await ProcessUtils.StartProcess (psi, stdout, stderr, cancellationToken, envVars).ConfigureAwait (false);
+		var psi = ProcessUtils.CreateProcessStartInfo (adbPath, "devices", "-l");
+		var exitCode = await ProcessUtils.StartProcess (psi, stdout, stderr, cancellationToken, environmentVariables).ConfigureAwait (false);
 
 		ProcessUtils.ThrowIfFailed (exitCode, "adb devices -l", stderr.ToString ());
 
@@ -88,7 +61,7 @@ public async Task<IReadOnlyList<AdbDeviceInfo>> ListDevicesAsync (CancellationTo
 		// For each emulator, try to get the AVD name
 		foreach (var device in devices) {
 			if (device.Type == AdbDeviceType.Emulator) {
-				device.AvdName = await GetEmulatorAvdNameAsync (adb, device.Serial, cancellationToken).ConfigureAwait (false);
+				device.AvdName = await GetEmulatorAvdNameAsync (device.Serial, cancellationToken).ConfigureAwait (false);
 				device.Description = BuildDeviceDescription (device);
 			}
 		}
@@ -101,13 +74,12 @@ public async Task<IReadOnlyList<AdbDeviceInfo>> ListDevicesAsync (CancellationTo
 	/// falling back to a direct emulator console TCP query if that fails.
 	/// Ported from dotnet/android GetAvailableAndroidDevices.GetEmulatorAvdName.
 	/// </summary>
-	internal async Task<string?> GetEmulatorAvdNameAsync (string adbPath, string serial, CancellationToken cancellationToken = default)
+	internal async Task<string?> GetEmulatorAvdNameAsync (string serial, CancellationToken cancellationToken = default)
 	{
 		try {
-			var envVars = GetEnvironmentVariables ();
 			using var stdout = new StringWriter ();
 			var psi = ProcessUtils.CreateProcessStartInfo (adbPath, "-s", serial, "emu", "avd", "name");
-			await ProcessUtils.StartProcess (psi, stdout, null, cancellationToken, envVars).ConfigureAwait (false);
+			await ProcessUtils.StartProcess (psi, stdout, null, cancellationToken, environmentVariables).ConfigureAwait (false);
 
 			foreach (var line in stdout.ToString ().Split ('\n')) {
 				var trimmed = line.Trim ();
@@ -187,14 +159,11 @@ public async Task WaitForDeviceAsync (string? serial = null, TimeSpan? timeout =
 		if (effectiveTimeout <= TimeSpan.Zero)
 			throw new ArgumentOutOfRangeException (nameof (timeout), effectiveTimeout, "Timeout must be a positive value.");
 
-		var adb = RequireAdb ();
-		var envVars = GetEnvironmentVariables ();
-
 		var args = string.IsNullOrEmpty (serial)
 			? new [] { "wait-for-device" }
-			: new [] { "-s", serial!, "wait-for-device" };
+			: new [] { "-s", serial, "wait-for-device" };
 
-		var psi = ProcessUtils.CreateProcessStartInfo (adb, args);
+		var psi = ProcessUtils.CreateProcessStartInfo (adbPath, args);
 
 		using var cts = CancellationTokenSource.CreateLinkedTokenSource (cancellationToken);
 		cts.CancelAfter (effectiveTimeout);
@@ -203,7 +172,7 @@ public async Task WaitForDeviceAsync (string? serial = null, TimeSpan? timeout =
 		using var stderr = new StringWriter ();
 
 		try {
-			var exitCode = await ProcessUtils.StartProcess (psi, stdout, stderr, cts.Token, envVars).ConfigureAwait (false);
+			var exitCode = await ProcessUtils.StartProcess (psi, stdout, stderr, cts.Token, environmentVariables).ConfigureAwait (false);
 			ProcessUtils.ThrowIfFailed (exitCode, "adb wait-for-device", stderr.ToString (), stdout.ToString ());
 		} catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested) {
 			throw new TimeoutException ($"Timed out waiting for device after {effectiveTimeout.TotalSeconds}s.");
@@ -215,11 +184,9 @@ public async Task StopEmulatorAsync (string serial, CancellationToken cancellati
 		if (string.IsNullOrWhiteSpace (serial))
 			throw new ArgumentException ("Serial must not be empty.", nameof (serial));
 
-		var adb = RequireAdb ();
-		var envVars = GetEnvironmentVariables ();
-		var psi = ProcessUtils.CreateProcessStartInfo (adb, "-s", serial, "emu", "kill");
+		var psi = ProcessUtils.CreateProcessStartInfo (adbPath, "-s", serial, "emu", "kill");
 		using var stderr = new StringWriter ();
-		var exitCode = await ProcessUtils.StartProcess (psi, null, stderr, cancellationToken, envVars).ConfigureAwait (false);
+		var exitCode = await ProcessUtils.StartProcess (psi, null, stderr, cancellationToken, environmentVariables).ConfigureAwait (false);
 		ProcessUtils.ThrowIfFailed (exitCode, $"adb -s {serial} emu kill", stderr.ToString ());
 	}
 

tests/Xamarin.Android.Tools.AndroidSdk-Tests/AdbRunnerTests.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 using System.Collections.Generic;
 using System.IO;
 using NUnit.Framework;
@@ -486,32 +487,21 @@ public void MergeDevicesAndEmulators_EmptyAdbDevices_ReturnsAllAvailable ()
 	// Consumer: MAUI DevTools Adb provider (AdbPath, IsAvailable properties)
 
 	[Test]
-	public void AdbPath_FindsInSdk ()
+	public void Constructor_NullPath_ThrowsArgumentException ()
 	{
-		var tempDir = Path.Combine (Path.GetTempPath (), $"adb-test-{Path.GetRandomFileName ()}");
-		var platformTools = Path.Combine (tempDir, "platform-tools");
-		Directory.CreateDirectory (platformTools);
-
-		try {
-			var adbName = OS.IsWindows ? "adb.exe" : "adb";
-			File.WriteAllText (Path.Combine (platformTools, adbName), "");
-
-			var runner = new AdbRunner (() => tempDir);
+		Assert.Throws<ArgumentException> (() => new AdbRunner (null!));
+	}
 
-			Assert.IsNotNull (runner.AdbPath);
-			Assert.IsTrue (runner.IsAvailable);
-			Assert.IsTrue (runner.AdbPath!.Contains ("platform-tools"));
-		} finally {
-			Directory.Delete (tempDir, true);
-		}
+	[Test]
+	public void Constructor_EmptyPath_ThrowsArgumentException ()
+	{
+		Assert.Throws<ArgumentException> (() => new AdbRunner (""));
 	}
 
 	[Test]
-	public void AdbPath_NullSdkPath_StillSearchesPath ()
+	public void Constructor_WhitespacePath_ThrowsArgumentException ()
 	{
-		var runner = new AdbRunner (() => null);
-		// Should not throw — falls back to PATH search
-		_ = runner.AdbPath;
+		Assert.Throws<ArgumentException> (() => new AdbRunner ("   "));
 	}
 
 	[Test]
@@ -627,15 +617,15 @@ public void MapAdbStateToStatus_Sideload_ReturnsUnknown ()
 	[Test]
 	public void WaitForDeviceAsync_NegativeTimeout_ThrowsArgumentOutOfRange ()
 	{
-		var runner = new AdbRunner (() => "/fake/sdk");
+		var runner = new AdbRunner ("/fake/sdk/platform-tools/adb");
 		Assert.ThrowsAsync<System.ArgumentOutOfRangeException> (
 			async () => await runner.WaitForDeviceAsync (timeout: System.TimeSpan.FromSeconds (-1)));
 	}
 
 	[Test]
 	public void WaitForDeviceAsync_ZeroTimeout_ThrowsArgumentOutOfRange ()
 	{
-		var runner = new AdbRunner (() => "/fake/sdk");
+		var runner = new AdbRunner ("/fake/sdk/platform-tools/adb");
 		Assert.ThrowsAsync<System.ArgumentOutOfRangeException> (
 			async () => await runner.WaitForDeviceAsync (timeout: System.TimeSpan.Zero));
 	}

tests/Xamarin.Android.Tools.AndroidSdk-Tests/RunnerIntegrationTests.cs

@@ -25,6 +25,7 @@ public class RunnerIntegrationTests
 {
 	static string sdkPath;
 	static string jdkPath;
+	static string adbPath;
 	static SdkManager sdkManager;
 	static string bootstrappedSdkPath;
 
@@ -88,6 +89,12 @@ public async Task OneTimeSetUp ()
 			sdkManager.JavaSdkPath = jdkPath;
 			sdkManager.AndroidSdkPath = sdkPath;
 		}
+
+		// Resolve the full path to adb for AdbRunner
+		var adbExe = OS.IsWindows ? "adb.exe" : "adb";
+		adbPath = Path.Combine (sdkPath, "platform-tools", adbExe);
+		if (!File.Exists (adbPath))
+			Assert.Ignore ($"adb not found at {adbPath}");
 	}
 
 	[OneTimeTearDown]
@@ -112,19 +119,16 @@ public void OneTimeTearDown ()
 	// ── AdbRunner integration ──────────────────────────────────────
 
 	[Test]
-	public void AdbRunner_IsAvailable_WithSdk ()
+	public void AdbRunner_Constructor_AcceptsValidPath ()
 	{
-		var runner = new AdbRunner (() => sdkPath);
-
-		Assert.IsTrue (runner.IsAvailable, "AdbRunner should find adb in SDK");
-		Assert.IsNotNull (runner.AdbPath);
-		Assert.IsTrue (File.Exists (runner.AdbPath), $"adb binary should exist at {runner.AdbPath}");
+		var runner = new AdbRunner (adbPath);
+		Assert.IsNotNull (runner);
 	}
 
 	[Test]
 	public async Task AdbRunner_ListDevicesAsync_ReturnsWithoutError ()
 	{
-		var runner = new AdbRunner (() => sdkPath);
+		var runner = new AdbRunner (adbPath);
 
 		// On CI there are no physical devices or emulators, but the command
 		// should succeed and return an empty (or non-null) list.
@@ -137,9 +141,7 @@ public async Task AdbRunner_ListDevicesAsync_ReturnsWithoutError ()
 	[Test]
 	public void AdbRunner_WaitForDeviceAsync_TimesOut_WhenNoDevice ()
 	{
-		var runner = new AdbRunner (() => sdkPath);
-
-		// With no devices connected, wait-for-device should time out
+		var runner = new AdbRunner (adbPath);
 		var ex = Assert.ThrowsAsync<TimeoutException> (async () =>
 			await runner.WaitForDeviceAsync (timeout: TimeSpan.FromSeconds (5)));
 
@@ -152,11 +154,10 @@ public void AdbRunner_WaitForDeviceAsync_TimesOut_WhenNoDevice ()
 	[Test]
 	public void AllRunners_ToolDiscovery_ConsistentWithSdk ()
 	{
-		var adb = new AdbRunner (() => sdkPath);
-
-		Assert.IsTrue (adb.IsAvailable, "adb should be available");
+		var runner = new AdbRunner (adbPath);
 
 		// adb path should be under the SDK
-		StringAssert.StartsWith (sdkPath, adb.AdbPath!);
+		Assert.IsTrue (File.Exists (adbPath), $"adb should exist at {adbPath}");
+		StringAssert.StartsWith (sdkPath, adbPath);
 	}
 }