Support concurrent ADB device selection

Author: besendorf

acquisition/acquisition.go

@@ -19,7 +19,6 @@ import (
 	"github.com/botherder/go-savetime/hashes"
 	"github.com/google/uuid"
 	"github.com/mvt-project/androidqf/adb"
-	"github.com/mvt-project/androidqf/assets"
 	"github.com/mvt-project/androidqf/log"
 	"github.com/mvt-project/androidqf/utils"
 )
@@ -178,10 +177,6 @@ func (a *Acquisition) Complete() {
 	if a.Collector != nil {
 		a.Collector.Clean()
 	}
-
-	// Stop ADB server before trying to remove extracted assets
-	adb.Client.KillServer()
-	assets.CleanAssets()
 }
 
 func (a *Acquisition) GetSystemInformation() error {

adb/adb.go

@@ -32,9 +32,6 @@ func New() (*ADB, error) {
 	}
 	log.Debugf("ADB found at path: %s", adb.ExePath)
 
-	log.Debug("Killing existing ADB server if running")
-	adb.KillServer()
-
 	// Confirm that we can call "adb devices" without errors
 	_, err = adb.Devices()
 	if err != nil {
@@ -63,11 +60,10 @@ func (a *ADB) SetSerial(serial string) (string, error) {
 		}
 		a.Serial = serial
 	} else {
-		// Problem if multiple devices
 		if len(devices) > 1 {
 			return "", fmt.Errorf("multiple devices connected, please stop AndroidQF and provide a serial number")
 		}
-		a.Serial = ""
+		a.Serial = devices[0]
 	}
 	return a.Serial, nil
 }

adb/adb_test.go

@@ -0,0 +1,75 @@
+package adb
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestMain(m *testing.M) {
+	if os.Getenv("ANDROIDQF_FAKE_ADB") == "1" {
+		fakeADB()
+		return
+	}
+	os.Exit(m.Run())
+}
+
+func fakeADB() {
+	if len(os.Args) < 2 {
+		os.Exit(2)
+	}
+
+	switch os.Args[1] {
+	case "devices":
+		fmt.Println("List of devices attached")
+		for _, device := range strings.Split(os.Getenv("ANDROIDQF_FAKE_ADB_DEVICES"), ",") {
+			device = strings.TrimSpace(device)
+			if device != "" {
+				fmt.Printf("%s\tdevice\n", device)
+			}
+		}
+	default:
+		os.Exit(2)
+	}
+}
+
+func newFakeADB(t *testing.T, devices string) *ADB {
+	t.Helper()
+	t.Setenv("ANDROIDQF_FAKE_ADB", "1")
+	t.Setenv("ANDROIDQF_FAKE_ADB_DEVICES", devices)
+	return &ADB{ExePath: os.Args[0]}
+}
+
+func TestSetSerialSingleDeviceUsesExplicitSerial(t *testing.T) {
+	client := newFakeADB(t, "device-1")
+	serial, err := client.SetSerial("")
+	if err != nil {
+		t.Fatalf("SetSerial returned error: %v", err)
+	}
+	if serial != "device-1" {
+		t.Fatalf("serial = %q, want device-1", serial)
+	}
+	if client.Serial != "device-1" {
+		t.Fatalf("client.Serial = %q, want device-1", client.Serial)
+	}
+}
+
+func TestSetSerialMultipleDevicesWithoutSerialErrors(t *testing.T) {
+	client := newFakeADB(t, "device-1,device-2")
+	_, err := client.SetSerial("")
+	if err == nil {
+		t.Fatal("SetSerial returned nil error, want multiple devices error")
+	}
+}
+
+func TestSetSerialExplicitSerial(t *testing.T) {
+	client := newFakeADB(t, "device-1,device-2")
+	serial, err := client.SetSerial("device-2")
+	if err != nil {
+		t.Fatalf("SetSerial returned error: %v", err)
+	}
+	if serial != "device-2" {
+		t.Fatalf("serial = %q, want device-2", serial)
+	}
+}

device_selection_test.go

@@ -0,0 +1,118 @@
+package main
+
+import (
+	"errors"
+	"testing"
+	"time"
+)
+
+func TestResolveADBSerialNoDevicesDoesNotPrompt(t *testing.T) {
+	called := false
+	serial, prompted, err := resolveADBSerial("", nil, func([]deviceMenuItem) (string, error) {
+		called = true
+		return "", nil
+	}, nil)
+	if err != nil {
+		t.Fatalf("resolveADBSerial returned error: %v", err)
+	}
+	if serial != "" {
+		t.Fatalf("serial = %q, want empty", serial)
+	}
+	if prompted {
+		t.Fatal("prompted = true, want false")
+	}
+	if called {
+		t.Fatal("selector was called for zero devices")
+	}
+}
+
+func TestResolveADBSerialSingleDeviceDoesNotPrompt(t *testing.T) {
+	called := false
+	serial, prompted, err := resolveADBSerial("", []string{"device-1"}, func([]deviceMenuItem) (string, error) {
+		called = true
+		return "", nil
+	}, nil)
+	if err != nil {
+		t.Fatalf("resolveADBSerial returned error: %v", err)
+	}
+	if serial != "device-1" {
+		t.Fatalf("serial = %q, want device-1", serial)
+	}
+	if prompted {
+		t.Fatal("prompted = true, want false")
+	}
+	if called {
+		t.Fatal("selector was called for one device")
+	}
+}
+
+func TestResolveADBSerialMultipleDevicesPromptsWithRunningStatus(t *testing.T) {
+	started := time.Date(2026, 7, 7, 10, 11, 12, 0, time.UTC)
+	running := map[string]runningExtraction{
+		"device-2": {
+			Serial:  "device-2",
+			PID:     1234,
+			Started: started,
+		},
+	}
+
+	var gotItems []deviceMenuItem
+	serial, prompted, err := resolveADBSerial("", []string{"device-1", "device-2"}, func(items []deviceMenuItem) (string, error) {
+		gotItems = items
+		return items[1].Serial, nil
+	}, running)
+	if err != nil {
+		t.Fatalf("resolveADBSerial returned error: %v", err)
+	}
+	if serial != "device-2" {
+		t.Fatalf("serial = %q, want device-2", serial)
+	}
+	if !prompted {
+		t.Fatal("prompted = false, want true")
+	}
+	if len(gotItems) != 2 {
+		t.Fatalf("selector got %d items, want 2", len(gotItems))
+	}
+	if gotItems[0].Status != "" {
+		t.Fatalf("first item status = %q, want empty", gotItems[0].Status)
+	}
+	if gotItems[1].Status == "" {
+		t.Fatal("second item status is empty, want running extraction status")
+	}
+}
+
+func TestResolveADBSerialMultipleDevicesReturnsSelectorError(t *testing.T) {
+	wantErr := errors.New("selection failed")
+	serial, prompted, err := resolveADBSerial("", []string{"device-1", "device-2"}, func([]deviceMenuItem) (string, error) {
+		return "", wantErr
+	}, nil)
+	if !errors.Is(err, wantErr) {
+		t.Fatalf("err = %v, want %v", err, wantErr)
+	}
+	if serial != "" {
+		t.Fatalf("serial = %q, want empty", serial)
+	}
+	if !prompted {
+		t.Fatal("prompted = false, want true")
+	}
+}
+
+func TestResolveADBSerialExplicitSerialDoesNotPrompt(t *testing.T) {
+	called := false
+	serial, prompted, err := resolveADBSerial("requested", []string{"device-1", "device-2"}, func([]deviceMenuItem) (string, error) {
+		called = true
+		return "", nil
+	}, nil)
+	if err != nil {
+		t.Fatalf("resolveADBSerial returned error: %v", err)
+	}
+	if serial != "requested" {
+		t.Fatalf("serial = %q, want requested", serial)
+	}
+	if prompted {
+		t.Fatal("prompted = true, want false")
+	}
+	if called {
+		t.Fatal("selector was called for explicit serial")
+	}
+}

main.go

@@ -21,6 +21,11 @@ import (
 	"github.com/mvt-project/androidqf/utils"
 )
 
+type deviceMenuItem struct {
+	Serial string
+	Status string
+}
+
 func init() {
 	cfmt.Print(`
 	{{                    __           _     __      ____ }}::green
@@ -39,18 +44,52 @@ func systemPause() {
 	os.Stdin.Read(make([]byte, 1))
 }
 
-func selectADBDevice(devices []string) (string, error) {
+func buildDeviceMenuItems(devices []string, running map[string]runningExtraction) []deviceMenuItem {
+	items := make([]deviceMenuItem, 0, len(devices))
+	for _, device := range devices {
+		item := deviceMenuItem{Serial: device}
+		if state, ok := running[device]; ok {
+			item.Status = fmt.Sprintf("(extraction running, pid %d, started %s)", state.PID, state.Started.Local().Format("2006-01-02 15:04:05"))
+		}
+		items = append(items, item)
+	}
+	return items
+}
+
+func selectADBDeviceFromMenu(items []deviceMenuItem) (string, error) {
 	promptDevice := promptui.Select{
 		Label: "Multiple Android devices detected. Select the device to acquire",
-		Items: devices,
+		Items: items,
+		Templates: &promptui.SelectTemplates{
+			Active:   "> {{ .Serial | cyan }} {{ .Status | yellow }}",
+			Inactive: "  {{ .Serial }} {{ .Status }}",
+			Selected: "{{ .Serial }}",
+		},
 	}
 
-	_, device, err := promptDevice.Run()
+	index, _, err := promptDevice.Run()
 	if err != nil {
 		return "", fmt.Errorf("failed to select ADB device: %v", err)
 	}
 
-	return device, nil
+	return items[index].Serial, nil
+}
+
+func selectADBDevice(devices []string) (string, error) {
+	return selectADBDeviceFromMenu(buildDeviceMenuItems(devices, activeRunningExtractionsBySerial()))
+}
+
+func resolveADBSerial(serial string, devices []string, selectDevice func([]deviceMenuItem) (string, error), running map[string]runningExtraction) (string, bool, error) {
+	serial = strings.TrimSpace(serial)
+	if serial != "" || len(devices) == 0 {
+		return serial, false, nil
+	}
+	if len(devices) == 1 {
+		return devices[0], false, nil
+	}
+
+	selectedSerial, err := selectDevice(buildDeviceMenuItems(devices, running))
+	return selectedSerial, true, err
 }
 
 func main() {
@@ -119,15 +158,16 @@ func main() {
 			}
 		}
 	}
+	specificDeviceRequested := serial != ""
 
 	// Initialization
 	for {
 		if serial == "" {
 			devices, err := adb.Client.Devices()
 			if err != nil {
 				log.Error(fmt.Sprintf("Error listing ADB devices: %s", err))
-			} else if len(devices) > 1 {
-				serial, err = selectADBDevice(devices)
+			} else {
+				serial, _, err = resolveADBSerial(serial, devices, selectADBDeviceFromMenu, activeRunningExtractionsBySerial())
 				if err != nil {
 					log.Error(fmt.Sprintf("Error selecting ADB device: %s", err))
 					time.Sleep(5 * time.Second)
@@ -139,17 +179,35 @@ func main() {
 		serial, err = adb.Client.SetSerial(serial)
 		if err != nil {
 			log.Error(fmt.Sprintf("Error trying to connect over ADB: %s", err))
+			if !specificDeviceRequested {
+				serial = ""
+			}
 		} else {
 			_, err = adb.Client.GetState()
 			if err == nil {
 				break
 			}
 			log.Debug(err)
 			log.Error("Unable to get device state. Please make sure it is connected and authorized. Trying again in 5 seconds...")
+			if !specificDeviceRequested {
+				serial = ""
+			}
 		}
 		time.Sleep(5 * time.Second)
 	}
 
+	releaseRunning, err := registerRunningExtraction(adb.Client.Serial, "")
+	if err != nil {
+		log.Warningf("Unable to record running extraction state: %v", err)
+		releaseRunning = func() {}
+	}
+	runningReleased := false
+	defer func() {
+		if !runningReleased {
+			releaseRunning()
+		}
+	}()
+
 	acq, err := acquisition.New(output_folder)
 	if err != nil {
 		log.Debug(err)
@@ -201,6 +259,8 @@ func main() {
 	}
 
 	acq.Complete()
+	releaseRunning()
+	runningReleased = true
 	log.Info("Acquisition completed.")
 
 	systemPause()