Refactor Android boot fast lookup for testability

Author: thymikee

src/daemon/handlers/__tests__/session.test.ts

@@ -379,7 +379,7 @@ test('boot --headless launches Android emulator when no running device matches',
       session: 'default',
       command: 'boot',
       positionals: [],
-      flags: { platform: 'android', target: 'mobile', device: 'Pixel_9_Pro_XL', headless: true },
+      flags: { platform: 'android', device: 'Pixel_9_Pro_XL', headless: true },
     },
     sessionName: 'default',
     logPath: path.join(os.tmpdir(), 'daemon.log'),
@@ -391,6 +391,7 @@ test('boot --headless launches Android emulator when no running device matches',
     resolveTargetDevice: async () => {
       throw new AppError('DEVICE_NOT_FOUND', 'No devices found');
     },
+    resolveAndroidBootSelectorDevice: async () => undefined,
     ensureAndroidEmulatorBoot: async ({ avdName, serial, headless }) => {
       launchCalls.push({ avdName, serial, headless });
       return {
@@ -424,7 +425,7 @@ test('boot launches Android emulator with GUI when no running device matches', a
       session: 'default',
       command: 'boot',
       positionals: [],
-      flags: { platform: 'android', target: 'mobile', device: 'Pixel_9_Pro_XL' },
+      flags: { platform: 'android', device: 'Pixel_9_Pro_XL' },
     },
     sessionName: 'default',
     logPath: path.join(os.tmpdir(), 'daemon.log'),
@@ -434,6 +435,7 @@ test('boot launches Android emulator with GUI when no running device matches', a
     resolveTargetDevice: async () => {
       throw new AppError('DEVICE_NOT_FOUND', 'No devices found');
     },
+    resolveAndroidBootSelectorDevice: async () => undefined,
     ensureAndroidEmulatorBoot: async ({ avdName, serial, headless }) => {
       launchCalls.push({ avdName, serial, headless });
       return {
@@ -466,7 +468,7 @@ test('boot --headless requires avd selector when device cannot be resolved', asy
       session: 'default',
       command: 'boot',
       positionals: [],
-      flags: { platform: 'android', target: 'mobile', serial: 'emulator-5554', headless: true },
+      flags: { platform: 'android', serial: 'emulator-5554', headless: true },
     },
     sessionName: 'default',
     logPath: path.join(os.tmpdir(), 'daemon.log'),
@@ -476,6 +478,7 @@ test('boot --headless requires avd selector when device cannot be resolved', asy
     resolveTargetDevice: async () => {
       throw new AppError('DEVICE_NOT_FOUND', 'No devices found');
     },
+    resolveAndroidBootSelectorDevice: async () => undefined,
     ensureAndroidEmulatorBoot: async () => {
       bootCalled = true;
       throw new Error('unexpected');
@@ -491,6 +494,45 @@ test('boot --headless requires avd selector when device cannot be resolved', asy
   }
 });
 
+test('boot uses fast Android selector lookup for already booted device', async () => {
+  const sessionStore = makeSessionStore();
+  let ensureCalls = 0;
+  const response = await handleSessionCommands({
+    req: {
+      token: 't',
+      session: 'default',
+      command: 'boot',
+      positionals: [],
+      flags: { platform: 'android', device: 'Pixel 9 Pro XL' },
+    },
+    sessionName: 'default',
+    logPath: path.join(os.tmpdir(), 'daemon.log'),
+    sessionStore,
+    invoke: noopInvoke,
+    ensureReady: async () => {
+      ensureCalls += 1;
+    },
+    resolveTargetDevice: async () => {
+      throw new Error('resolveTargetDevice should not be called when fast lookup succeeds');
+    },
+    resolveAndroidBootSelectorDevice: async () => ({
+      platform: 'android',
+      id: 'emulator-5554',
+      name: 'Pixel 9 Pro XL',
+      kind: 'emulator',
+      target: 'mobile',
+      booted: true,
+    }),
+  });
+  assert.ok(response);
+  assert.equal(response?.ok, true);
+  assert.equal(ensureCalls, 0);
+  if (response && response.ok) {
+    assert.equal(response.data?.platform, 'android');
+    assert.equal(response.data?.id, 'emulator-5554');
+  }
+});
+
 test('appstate on iOS requires active session on selected device', async () => {
   const sessionStore = makeSessionStore();
   const sessionName = 'default';

src/daemon/handlers/session.ts

@@ -54,6 +54,11 @@ type EnsureAndroidEmulatorBoot = (params: {
   headless?: boolean;
 }) => Promise<DeviceInfo>;
 
+type ResolveAndroidBootSelectorDevice = (params: {
+  deviceName?: string;
+  serial?: string;
+}) => Promise<DeviceInfo | undefined>;
+
 const IOS_APPSTATE_SESSION_REQUIRED_MESSAGE =
   'iOS appstate requires an active session on the target device. Run open first (for example: open --session sim --platform ios --device "<name>" <app>).';
 const BATCH_PARENT_FLAG_KEYS: Array<keyof CommandFlags> = ['platform', 'target', 'device', 'udid', 'serial', 'verbose', 'out'];
@@ -253,6 +258,11 @@ const defaultEnsureAndroidEmulatorBoot: EnsureAndroidEmulatorBoot = async ({ avd
   return await ensureAndroidEmulatorBooted({ avdName, serial, headless });
 };
 
+const defaultResolveAndroidBootSelectorDevice: ResolveAndroidBootSelectorDevice = async ({ deviceName, serial }) => {
+  const { resolveAndroidBootSelectorDevice } = await import('../../platforms/android/devices.ts');
+  return await resolveAndroidBootSelectorDevice({ deviceName, serial });
+};
+
 const defaultReinstallOps: ReinstallOps = {
   ios: async (device, app, appPath) => {
     const { reinstallIosApp } = await import('../../platforms/ios/index.ts');
@@ -470,6 +480,7 @@ export async function handleSessionCommands(params: {
     stop: typeof stopAppLog;
   };
   ensureAndroidEmulatorBoot?: EnsureAndroidEmulatorBoot;
+  resolveAndroidBootSelectorDevice?: ResolveAndroidBootSelectorDevice;
   resolveAndroidPackageForOpen?: (
     device: DeviceInfo,
     openTarget: string | undefined,
@@ -491,6 +502,7 @@ export async function handleSessionCommands(params: {
       stop: stopAppLog,
     },
     ensureAndroidEmulatorBoot: ensureAndroidEmulatorBootOverride = defaultEnsureAndroidEmulatorBoot,
+    resolveAndroidBootSelectorDevice: resolveAndroidBootSelectorDeviceOverride = defaultResolveAndroidBootSelectorDevice,
     resolveAndroidPackageForOpen: resolveAndroidPackageForOpenOverride = resolveAndroidPackageForOpen,
   } = params;
   const dispatch = dispatchOverride ?? dispatchCommand;
@@ -587,23 +599,24 @@ export async function handleSessionCommands(params: {
     const normalizedPlatform = normalizePlatformSelector(flags.platform) ?? session?.device.platform;
     const targetsAndroid = normalizedPlatform === 'android';
     const wantsAndroidHeadless = flags.headless === true;
-    const shouldUseFastAndroidSelectorLookup = targetsAndroid && !flags.target && Boolean(flags.device || flags.serial);
+    const shouldUseFastAndroidSelectorLookup = targetsAndroid && Boolean(flags.device || flags.serial);
     const fallbackAvdName = resolveAndroidEmulatorAvdName({
       flags,
       sessionDevice: session?.device,
     });
     const canFallbackLaunchAndroidEmulator = targetsAndroid && Boolean(fallbackAvdName);
     let device: DeviceInfo;
     let launchedAndroidEmulator = false;
-    const fastLookupDevice = shouldUseFastAndroidSelectorLookup
-      ? await (async () => {
-        const { resolveAndroidBootSelectorDevice } = await import('../../platforms/android/devices.ts');
-        return await resolveAndroidBootSelectorDevice({
-          deviceName: flags.device,
-          serial: flags.serial,
-        });
-      })()
+    const fastLookupDeviceCandidate = shouldUseFastAndroidSelectorLookup
+      ? await resolveAndroidBootSelectorDeviceOverride({
+        deviceName: flags.device,
+        serial: flags.serial,
+      })
       : undefined;
+    const targetMismatch = Boolean(flags.target)
+      && fastLookupDeviceCandidate
+      && (fastLookupDeviceCandidate.target ?? 'mobile') !== flags.target;
+    const fastLookupDevice = targetMismatch ? undefined : fastLookupDeviceCandidate;
     try {
       device = fastLookupDevice
         ?? (await resolveCommandDevice({

src/platforms/android/__tests__/devices.test.ts

@@ -189,6 +189,7 @@ test('resolveAndroidBootSelectorDevice matches emulator by device name', async (
     assert.ok(device);
     assert.equal(device?.id, 'emulator-5554');
     assert.equal(device?.kind, 'emulator');
+    assert.equal(device?.target, 'mobile');
     assert.equal(device?.booted, true);
   });
 });

src/platforms/android/devices.ts

@@ -230,12 +230,16 @@ export async function resolveAndroidBootSelectorDevice(params: {
   }
 
   if (!matched) return undefined;
-  const booted = await isAndroidBooted(matched.serial);
+  const [booted, target] = await Promise.all([
+    isAndroidBooted(matched.serial),
+    resolveAndroidTarget(matched.serial),
+  ]);
   return {
     platform: 'android',
     id: matched.serial,
     name: matchedName ?? (matched.rawModel.replace(/_/g, ' ').trim() || matched.serial),
     kind: isEmulatorSerial(matched.serial) ? 'emulator' : 'device',
+    target,
     booted,
   };
 }