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 @@
 usingSystem.Diagnostics;
 usingSystem.Globalization;
 usingSystem.IO;
-usingSystem.Linq;
 usingSystem.Net.Sockets;
 usingSystem.Text.RegularExpressions;
 usingSystem.Threading;
@@ -20,52 +19,28 @@ namespace Xamarin.Android.Tools;
 /// </summary>
 publicclassAdbRunner
 {
-readonlyFunc<string?>getSdkPath;
-readonlyFunc<string?>?getJdkPath;
+readonlystringadbPath;
+readonlyIDictionary<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.
 staticreadonlyRegexAdbDevicesRegex=newRegex(
 @"^([^\s]+)\s+(device|offline|unauthorized|authorizing|no permissions|recovery|sideload|bootloader|connecting|host)\s*(.*)$",
 RegexOptions.Compiled|RegexOptions.IgnoreCase);
 staticreadonlyRegexApiRegex=newRegex(@"\bApi\b",RegexOptions.Compiled);
 
-publicAdbRunner(Func<string?>getSdkPath)
-:this(getSdkPath,null)
-{
-}
-
-publicAdbRunner(Func<string?>getSdkPath,Func<string?>?getJdkPath)
-{
-this.getSdkPath=getSdkPath??thrownewArgumentNullException(nameof(getSdkPath));
-this.getJdkPath=getJdkPath;
-}
-
-publicstring?AdbPath{
-get{
-varsdkPath=getSdkPath();
-if(!string.IsNullOrEmpty(sdkPath)){
-varext=OS.IsWindows?".exe":"";
-varsdkAdb=Path.Combine(sdkPath,"platform-tools","adb"+ext);
-if(File.Exists(sdkAdb))
-returnsdkAdb;
-}
-returnProcessUtils.FindExecutablesInPath("adb").FirstOrDefault();
-}
-}
-
-publicboolIsAvailable=>AdbPathis not null;
-
-stringRequireAdb()
-{
-returnAdbPath??thrownewInvalidOperationException("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>
+publicAdbRunner(stringadbPath,IDictionary<string,string>?environmentVariables=null)
 {
-returnAndroidEnvironmentHelper.GetEnvironmentVariables(getSdkPath(),getJdkPath?.Invoke());
+if(string.IsNullOrWhiteSpace(adbPath))
+thrownewArgumentException("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>
 publicasyncTask<IReadOnlyList<AdbDeviceInfo>>ListDevicesAsync(CancellationTokencancellationToken=default)
 {
-varadb=RequireAdb();
-varenvVars=GetEnvironmentVariables();
 usingvarstdout=newStringWriter();
 usingvarstderr=newStringWriter();
-varpsi=ProcessUtils.CreateProcessStartInfo(adb,"devices","-l");
-varexitCode=awaitProcessUtils.StartProcess(psi,stdout,stderr,cancellationToken,envVars).ConfigureAwait(false);
+varpsi=ProcessUtils.CreateProcessStartInfo(adbPath,"devices","-l");
+varexitCode=awaitProcessUtils.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(vardeviceindevices){
 if(device.Type==AdbDeviceType.Emulator){
-device.AvdName=awaitGetEmulatorAvdNameAsync(adb,device.Serial,cancellationToken).ConfigureAwait(false);
+device.AvdName=awaitGetEmulatorAvdNameAsync(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>
-internalasyncTask<string?>GetEmulatorAvdNameAsync(stringadbPath,stringserial,CancellationTokencancellationToken=default)
+internalasyncTask<string?>GetEmulatorAvdNameAsync(stringserial,CancellationTokencancellationToken=default)
 {
 try{
-varenvVars=GetEnvironmentVariables();
 usingvarstdout=newStringWriter();
 varpsi=ProcessUtils.CreateProcessStartInfo(adbPath,"-s",serial,"emu","avd","name");
-awaitProcessUtils.StartProcess(psi,stdout,null,cancellationToken,envVars).ConfigureAwait(false);
+awaitProcessUtils.StartProcess(psi,stdout,null,cancellationToken,environmentVariables).ConfigureAwait(false);
 
 foreach(varlineinstdout.ToString().Split('\n')){
 vartrimmed=line.Trim();
@@ -187,14 +159,11 @@ public async Task WaitForDeviceAsync (string? serial = null, TimeSpan? timeout =
 if(effectiveTimeout<=TimeSpan.Zero)
 thrownewArgumentOutOfRangeException(nameof(timeout),effectiveTimeout,"Timeout must be a positive value.");
 
-varadb=RequireAdb();
-varenvVars=GetEnvironmentVariables();
-
 varargs=string.IsNullOrEmpty(serial)
 ?new[]{"wait-for-device"}
-:new[]{"-s",serial!,"wait-for-device"};
+:new[]{"-s",serial,"wait-for-device"};
 
-varpsi=ProcessUtils.CreateProcessStartInfo(adb,args);
+varpsi=ProcessUtils.CreateProcessStartInfo(adbPath,args);
 
 usingvarcts=CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
 cts.CancelAfter(effectiveTimeout);
@@ -203,7 +172,7 @@ public async Task WaitForDeviceAsync (string? serial = null, TimeSpan? timeout =
 usingvarstderr=newStringWriter();
 
 try{
-varexitCode=awaitProcessUtils.StartProcess(psi,stdout,stderr,cts.Token,envVars).ConfigureAwait(false);
+varexitCode=awaitProcessUtils.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){
 thrownewTimeoutException($"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))
 thrownewArgumentException("Serial must not be empty.",nameof(serial));
 
-varadb=RequireAdb();
-varenvVars=GetEnvironmentVariables();
-varpsi=ProcessUtils.CreateProcessStartInfo(adb,"-s",serial,"emu","kill");
+varpsi=ProcessUtils.CreateProcessStartInfo(adbPath,"-s",serial,"emu","kill");
 usingvarstderr=newStringWriter();
-varexitCode=awaitProcessUtils.StartProcess(psi,null,stderr,cancellationToken,envVars).ConfigureAwait(false);
+varexitCode=awaitProcessUtils.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.
 
+usingSystem;
 usingSystem.Collections.Generic;
 usingSystem.IO;
 usingNUnit.Framework;
@@ -486,32 +487,21 @@ public void MergeDevicesAndEmulators_EmptyAdbDevices_ReturnsAllAvailable ()
 // Consumer: MAUI DevTools Adb provider (AdbPath, IsAvailable properties)
 
 [Test]
-publicvoidAdbPath_FindsInSdk()
+publicvoidConstructor_NullPath_ThrowsArgumentException()
 {
-vartempDir=Path.Combine(Path.GetTempPath(),$"adb-test-{Path.GetRandomFileName()}");
-varplatformTools=Path.Combine(tempDir,"platform-tools");
-Directory.CreateDirectory(platformTools);
-
-try{
-varadbName=OS.IsWindows?"adb.exe":"adb";
-File.WriteAllText(Path.Combine(platformTools,adbName),"");
-
-varrunner=newAdbRunner(()=>tempDir);
+Assert.Throws<ArgumentException>(()=>newAdbRunner(null!));
+}
 
-Assert.IsNotNull(runner.AdbPath);
-Assert.IsTrue(runner.IsAvailable);
-Assert.IsTrue(runner.AdbPath!.Contains("platform-tools"));
-}finally{
-Directory.Delete(tempDir,true);
-}
+[Test]
+publicvoidConstructor_EmptyPath_ThrowsArgumentException()
+{
+Assert.Throws<ArgumentException>(()=>newAdbRunner(""));
 }
 
 [Test]
-publicvoidAdbPath_NullSdkPath_StillSearchesPath()
+publicvoidConstructor_WhitespacePath_ThrowsArgumentException()
 {
-varrunner=newAdbRunner(()=>null);
-// Should not throw — falls back to PATH search
-_=runner.AdbPath;
+Assert.Throws<ArgumentException>(()=>newAdbRunner(" "));
 }
 
 [Test]
@@ -627,15 +617,15 @@ public void MapAdbStateToStatus_Sideload_ReturnsUnknown ()
 [Test]
 publicvoidWaitForDeviceAsync_NegativeTimeout_ThrowsArgumentOutOfRange()
 {
-varrunner=newAdbRunner(()=>"/fake/sdk");
+varrunner=newAdbRunner("/fake/sdk/platform-tools/adb");
 Assert.ThrowsAsync<System.ArgumentOutOfRangeException>(
 async()=>awaitrunner.WaitForDeviceAsync(timeout:System.TimeSpan.FromSeconds(-1)));
 }
 
 [Test]
 publicvoidWaitForDeviceAsync_ZeroTimeout_ThrowsArgumentOutOfRange()
 {
-varrunner=newAdbRunner(()=>"/fake/sdk");
+varrunner=newAdbRunner("/fake/sdk/platform-tools/adb");
 Assert.ThrowsAsync<System.ArgumentOutOfRangeException>(
 async()=>awaitrunner.WaitForDeviceAsync(timeout:System.TimeSpan.Zero));
 }

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

@@ -25,6 +25,7 @@ public class RunnerIntegrationTests
 {
 staticstringsdkPath;
 staticstringjdkPath;
+staticstringadbPath;
 staticSdkManagersdkManager;
 staticstringbootstrappedSdkPath;
 
@@ -88,6 +89,12 @@ public async Task OneTimeSetUp ()
 sdkManager.JavaSdkPath=jdkPath;
 sdkManager.AndroidSdkPath=sdkPath;
 }
+
+// Resolve the full path to adb for AdbRunner
+varadbExe=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]
-publicvoidAdbRunner_IsAvailable_WithSdk()
+publicvoidAdbRunner_Constructor_AcceptsValidPath()
 {
-varrunner=newAdbRunner(()=>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}");
+varrunner=newAdbRunner(adbPath);
+Assert.IsNotNull(runner);
 }
 
 [Test]
 publicasyncTaskAdbRunner_ListDevicesAsync_ReturnsWithoutError()
 {
-varrunner=newAdbRunner(()=>sdkPath);
+varrunner=newAdbRunner(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]
 publicvoidAdbRunner_WaitForDeviceAsync_TimesOut_WhenNoDevice()
 {
-varrunner=newAdbRunner(()=>sdkPath);
-
-// With no devices connected, wait-for-device should time out
+varrunner=newAdbRunner(adbPath);
 varex=Assert.ThrowsAsync<TimeoutException>(async()=>
 awaitrunner.WaitForDeviceAsync(timeout:TimeSpan.FromSeconds(5)));
 
@@ -152,11 +154,10 @@ public void AdbRunner_WaitForDeviceAsync_TimesOut_WhenNoDevice ()
 [Test]
 publicvoidAllRunners_ToolDiscovery_ConsistentWithSdk()
 {
-varadb=newAdbRunner(()=>sdkPath);
-
-Assert.IsTrue(adb.IsAvailable,"adb should be available");
+varrunner=newAdbRunner(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);
 }
 }