@react-native-harness/platform-android 1.1.0-rc.1 → 1.1.0-rc.3

package/src/__tests__/shared-prefs.test.ts

@@ -0,0 +1,144 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import * as tools from '@react-native-harness/tools';
+import {
+  applyHarnessDebugHttpHost,
+  clearHarnessDebugHttpHost,
+} from '../shared-prefs.js';
+
+const bundleId = 'com.example.app';
+const adbId = 'emulator-5554';
+
+const getWrittenContent = (
+  calls: ReadonlyArray<readonly unknown[]>
+): string => {
+  const writeCall = calls.find(([, , options]) => {
+    if (!options || typeof options !== 'object' || !('stdin' in options)) {
+      return false;
+    }
+
+    return Boolean(options.stdin);
+  });
+  const options = writeCall?.[2];
+
+  if (!options || typeof options !== 'object' || !('stdin' in options)) {
+    throw new Error('Expected write call options.');
+  }
+
+  const content = options.stdin;
+
+  if (
+    !content ||
+    typeof content !== 'object' ||
+    !('string' in content) ||
+    typeof content.string !== 'string'
+  ) {
+    throw new Error('Expected write call with string stdin.');
+  }
+
+  return content.string;
+};
+
+const getWrittenContents = (
+  calls: ReadonlyArray<readonly unknown[]>
+): string[] =>
+  calls
+    .filter(([, , options]) => {
+      if (!options || typeof options !== 'object' || !('stdin' in options)) {
+        return false;
+      }
+
+      return Boolean(options.stdin);
+    })
+    .map((call) => getWrittenContent([call]));
+
+describe('Android shared preferences Metro host override', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('handles empty self-closing map files', async () => {
+    const spawnSpy = vi
+      .spyOn(tools, 'spawn')
+      .mockResolvedValueOnce({
+        stdout: '<?xml version="1.0" encoding="utf-8"?>\n<map />\n',
+      } as Awaited<ReturnType<typeof tools.spawn>>)
+      .mockResolvedValueOnce({} as Awaited<ReturnType<typeof tools.spawn>>);
+
+    await applyHarnessDebugHttpHost(adbId, bundleId, 'localhost:9090');
+
+    expect(getWrittenContent(spawnSpy.mock.calls)).toContain('<map>');
+    expect(getWrittenContent(spawnSpy.mock.calls)).toContain('</map>');
+    expect(getWrittenContent(spawnSpy.mock.calls)).toContain(
+      '<string name="debug_http_host">localhost:9090</string>'
+    );
+  });
+
+  it('restores the previous debug host on cleanup', async () => {
+    const spawnSpy = vi
+      .spyOn(tools, 'spawn')
+      .mockResolvedValueOnce({
+        stdout: [
+          '<?xml version="1.0" encoding="utf-8"?>',
+          '<map>',
+          '  <string name="debug_http_host">10.0.2.2:8081</string>',
+          '</map>',
+        ].join('\n'),
+      } as Awaited<ReturnType<typeof tools.spawn>>)
+      .mockResolvedValueOnce({} as Awaited<ReturnType<typeof tools.spawn>>)
+      .mockResolvedValueOnce({
+        stdout: [
+          '<?xml version="1.0" encoding="utf-8"?>',
+          '<map>',
+          '  <string name="debug_http_host">10.0.2.2:8081</string>',
+          '  <!-- react-native-harness:debug_http_host:start -->',
+          '  <string name="debug_http_host">localhost:9090</string>',
+          '  <!-- react-native-harness:debug_http_host:end -->',
+          '</map>',
+        ].join('\n'),
+      } as Awaited<ReturnType<typeof tools.spawn>>)
+      .mockResolvedValueOnce({} as Awaited<ReturnType<typeof tools.spawn>>);
+
+    await applyHarnessDebugHttpHost(adbId, bundleId, 'localhost:9090');
+    await clearHarnessDebugHttpHost(adbId, bundleId);
+
+    const writes = getWrittenContents(spawnSpy.mock.calls);
+    const firstWrite = writes[0];
+    const secondWrite = writes[1];
+
+    expect(firstWrite).toEqual(
+      expect.stringContaining(
+        '<string name="harness_debug_http_host_backup">10.0.2.2:8081</string>'
+      )
+    );
+    expect(firstWrite).toEqual(
+      expect.stringContaining(
+        '<string name="debug_http_host">localhost:9090</string>'
+      )
+    );
+    expect(firstWrite).toEqual(
+      expect.not.stringContaining(
+        '<string name="debug_http_host">10.0.2.2:8081</string>'
+      )
+    );
+    expect(secondWrite).toEqual(
+      expect.stringContaining(
+        '<string name="debug_http_host">10.0.2.2:8081</string>'
+      )
+    );
+    expect(secondWrite).toEqual(
+      expect.not.stringContaining(
+        '<string name="harness_debug_http_host_backup">10.0.2.2:8081</string>'
+      )
+    );
+    expect(secondWrite).toEqual(
+      expect.not.stringContaining(
+        '<!-- react-native-harness:debug_http_host:start -->'
+      )
+    );
+    expect(secondWrite).toEqual(
+      expect.not.stringContaining(
+        '<string name="debug_http_host">localhost:9090</string>'
+      )
+    );
+  });
+});

package/src/adb.ts

@@ -1,5 +1,169 @@
 import { type AndroidAppLaunchOptions } from '@react-native-harness/platforms';
 import { spawn, SubprocessError } from '@react-native-harness/tools';
+import { spawn as nodeSpawn } from 'node:child_process';
+import type { ChildProcessByStdio } from 'node:child_process';
+import { access, rm } from 'node:fs/promises';
+import type { Readable } from 'node:stream';
+import {
+  ensureAndroidSdkPackages,
+  getAdbBinaryPath,
+  getAndroidSystemImagePackage,
+  getAvdManagerBinaryPath,
+  getEmulatorBinaryPath,
+  getHostAndroidSystemImageArch,
+  getRequiredAndroidSdkPackages,
+  getSdkManagerBinaryPath,
+} from './environment.js';
+import {
+  getEmulatorStartupArgs,
+  type EmulatorBootMode,
+} from './emulator-startup.js';
+
+const wait = async (ms: number): Promise<void> => {
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+};
+
+const waitForAbort = (signal: AbortSignal): Promise<never> => {
+  if (signal.aborted) {
+    return Promise.reject(signal.reason);
+  }
+
+  return new Promise((_, reject) => {
+    signal.addEventListener(
+      'abort',
+      () => {
+        reject(signal.reason);
+      },
+      { once: true }
+    );
+  });
+};
+
+const waitWithSignal = async (
+  ms: number,
+  signal: AbortSignal
+): Promise<void> => {
+  if (signal.aborted) {
+    throw signal.reason;
+  }
+
+  await Promise.race([wait(ms), waitForAbort(signal)]);
+};
+
+const getAvdConfigPath = (name: string): string =>
+  `${
+    process.env.ANDROID_AVD_HOME ?? `${process.env.HOME}/.android/avd`
+  }/${name}.avd/config.ini`;
+
+const EMULATOR_STARTUP_OBSERVATION_TIMEOUT_MS = 5000;
+const EMULATOR_OUTPUT_BUFFER_LIMIT = 16 * 1024;
+
+export const emulatorProcess = {
+  startDetachedProcess: (
+    file: string,
+    args: readonly string[]
+  ): ChildProcessByStdio<null, Readable, Readable> =>
+    nodeSpawn(file, args, {
+      detached: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }),
+};
+
+const appendBoundedOutput = (
+  output: string,
+  chunk: string,
+  limit: number = EMULATOR_OUTPUT_BUFFER_LIMIT
+): string => {
+  const nextOutput = output + chunk;
+
+  if (nextOutput.length <= limit) {
+    return nextOutput;
+  }
+
+  return nextOutput.slice(-limit);
+};
+
+const formatEmulatorStartupError = ({
+  name,
+  stdout,
+  stderr,
+  exitCode,
+  signal,
+  error,
+}: {
+  name: string;
+  stdout: string;
+  stderr: string;
+  exitCode?: number | null;
+  signal?: NodeJS.Signals | null;
+  error?: unknown;
+}): Error => {
+  const sections = [`Failed to start Android emulator @${name}.`];
+
+  if (typeof exitCode === 'number') {
+    sections.push(`Exit code: ${exitCode}`);
+  }
+
+  if (signal) {
+    sections.push(`Signal: ${signal}`);
+  }
+
+  if (error instanceof Error) {
+    sections.push(`Cause: ${error.message}`);
+  }
+
+  const trimmedStdout = stdout.trim();
+  const trimmedStderr = stderr.trim();
+
+  if (trimmedStdout !== '') {
+    sections.push(`stdout:\n${trimmedStdout}`);
+  }
+
+  if (trimmedStderr !== '') {
+    sections.push(`stderr:\n${trimmedStderr}`);
+  }
+
+  return new Error(sections.join('\n\n'), {
+    cause: error instanceof Error ? error : undefined,
+  });
+};
+
+const ensureEmulatorInstalled = async (): Promise<string> => {
+  const emulatorBinaryPath = getEmulatorBinaryPath();
+
+  try {
+    await access(emulatorBinaryPath);
+    return emulatorBinaryPath;
+  } catch {
+    await spawn(getSdkManagerBinaryPath(), ['emulator']);
+    await access(emulatorBinaryPath);
+    return emulatorBinaryPath;
+  }
+};
+
+export type CreateAvdOptions = {
+  name: string;
+  apiLevel: number;
+  profile: string;
+  diskSize: string;
+  heapSize: string;
+};
+
+export const getRequiredEmulatorPackages = (apiLevel: number): string[] => {
+  return getRequiredAndroidSdkPackages({
+    apiLevel,
+    includeEmulator: true,
+    architecture: getHostAndroidSystemImageArch(),
+  });
+};
+
+export const verifyAndroidEmulatorSdk = async (
+  apiLevel: number
+): Promise<void> => {
+  await ensureAndroidSdkPackages(getRequiredEmulatorPackages(apiLevel));
+};
 
 export const getStartAppArgs = (
   bundleId: string,
@@ -47,7 +211,7 @@ export const isAppInstalled = async (
   adbId: string,
   bundleId: string
 ): Promise<boolean> => {
-  const { stdout } = await spawn('adb', [
+  const { stdout } = await spawn(getAdbBinaryPath(), [
     '-s',
     adbId,
     'shell',
@@ -64,7 +228,7 @@ export const reversePort = async (
   port: number,
   hostPort: number = port
 ): Promise<void> => {
-  await spawn('adb', [
+  await spawn(getAdbBinaryPath(), [
     '-s',
     adbId,
     'reverse',
@@ -77,7 +241,14 @@ export const stopApp = async (
   adbId: string,
   bundleId: string
 ): Promise<void> => {
-  await spawn('adb', ['-s', adbId, 'shell', 'am', 'force-stop', bundleId]);
+  await spawn(getAdbBinaryPath(), [
+    '-s',
+    adbId,
+    'shell',
+    'am',
+    'force-stop',
+    bundleId,
+  ]);
 };
 
 export const startApp = async (
@@ -86,11 +257,15 @@ export const startApp = async (
   activityName: string,
   options?: AndroidAppLaunchOptions
 ): Promise<void> => {
-  await spawn('adb', ['-s', adbId, ...getStartAppArgs(bundleId, activityName, options)]);
+  await spawn(getAdbBinaryPath(), [
+    '-s',
+    adbId,
+    ...getStartAppArgs(bundleId, activityName, options),
+  ]);
 };
 
 export const getDeviceIds = async (): Promise<string[]> => {
-  const { stdout } = await spawn('adb', ['devices']);
+  const { stdout } = await spawn(getAdbBinaryPath(), ['devices']);
   return stdout
     .split('\n')
     .slice(1) // Skip header
@@ -101,7 +276,13 @@ export const getDeviceIds = async (): Promise<string[]> => {
 export const getEmulatorName = async (
   adbId: string
 ): Promise<string | null> => {
-  const { stdout } = await spawn('adb', ['-s', adbId, 'emu', 'avd', 'name']);
+  const { stdout } = await spawn(getAdbBinaryPath(), [
+    '-s',
+    adbId,
+    'emu',
+    'avd',
+    'name',
+  ]);
   return stdout.split('\n')[0].trim() || null;
 };
 
@@ -109,7 +290,7 @@ export const getShellProperty = async (
   adbId: string,
   property: string
 ): Promise<string | null> => {
-  const { stdout } = await spawn('adb', [
+  const { stdout } = await spawn(getAdbBinaryPath(), [
     '-s',
     adbId,
     'shell',
@@ -119,6 +300,10 @@ export const getShellProperty = async (
   return stdout.trim() || null;
 };
 
+const isTransientAdbShellFailure = (error: unknown): boolean => {
+  return error instanceof SubprocessError && error.exitCode === 1;
+};
+
 export type DeviceInfo = {
   manufacturer: string | null;
   model: string | null;
@@ -133,12 +318,233 @@ export const getDeviceInfo = async (
 };
 
 export const isBootCompleted = async (adbId: string): Promise<boolean> => {
-  const bootCompleted = await getShellProperty(adbId, 'sys.boot_completed');
-  return bootCompleted === '1';
+  try {
+    const bootCompleted = await getShellProperty(adbId, 'sys.boot_completed');
+    return bootCompleted === '1';
+  } catch (error) {
+    if (isTransientAdbShellFailure(error)) {
+      return false;
+    }
+
+    throw error;
+  }
 };
 
 export const stopEmulator = async (adbId: string): Promise<void> => {
-  await spawn('adb', ['-s', adbId, 'emu', 'kill']);
+  await spawn(getAdbBinaryPath(), ['-s', adbId, 'emu', 'kill']);
+};
+
+export const installApp = async (
+  adbId: string,
+  appPath: string
+): Promise<void> => {
+  await spawn(getAdbBinaryPath(), ['-s', adbId, 'install', '-r', appPath]);
+};
+
+export const hasAvd = async (name: string): Promise<boolean> => {
+  const avds = await getAvds();
+  return avds.includes(name);
+};
+
+export const createAvd = async ({
+  name,
+  apiLevel,
+  profile,
+  diskSize,
+  heapSize,
+}: CreateAvdOptions): Promise<void> => {
+  const systemImagePackage = getAndroidSystemImagePackage(
+    apiLevel,
+    getHostAndroidSystemImageArch()
+  );
+
+  await verifyAndroidEmulatorSdk(apiLevel);
+  await spawn('bash', [
+    '-lc',
+    `printf 'no\n' | "${getAvdManagerBinaryPath()}" create avd --force --name "${name}" --package "${systemImagePackage}" --device "${profile}"`,
+  ]);
+  await spawn('bash', [
+    '-lc',
+    `printf '%s\n%s\n' 'disk.dataPartition.size=${diskSize}' 'vm.heapSize=${heapSize}' >> "${getAvdConfigPath(
+      name
+    )}"`,
+  ]);
+};
+
+export const deleteAvd = async (name: string): Promise<void> => {
+  await rm(
+    `${
+      process.env.ANDROID_AVD_HOME ?? `${process.env.HOME}/.android/avd`
+    }/${name}.avd`,
+    {
+      force: true,
+      recursive: true,
+    }
+  );
+  await rm(
+    `${
+      process.env.ANDROID_AVD_HOME ?? `${process.env.HOME}/.android/avd`
+    }/${name}.ini`,
+    {
+      force: true,
+    }
+  );
+};
+
+export const startEmulator = async (
+  name: string,
+  mode: EmulatorBootMode = 'default-boot'
+): Promise<void> => {
+  const emulatorBinaryPath = await ensureEmulatorInstalled();
+  const childProcess = emulatorProcess.startDetachedProcess(
+    emulatorBinaryPath,
+    getEmulatorStartupArgs(name, mode)
+  );
+
+  let stdout = '';
+  let stderr = '';
+
+  childProcess.stdout?.setEncoding('utf8');
+  childProcess.stderr?.setEncoding('utf8');
+
+  const onStdout = (chunk: string | Buffer) => {
+    stdout = appendBoundedOutput(stdout, chunk.toString());
+  };
+  const onStderr = (chunk: string | Buffer) => {
+    stderr = appendBoundedOutput(stderr, chunk.toString());
+  };
+
+  childProcess.stdout?.on('data', onStdout);
+  childProcess.stderr?.on('data', onStderr);
+
+  const startupAbortController = new AbortController();
+  const cleanup = () => {
+    startupAbortController.abort();
+    childProcess.stdout?.off('data', onStdout);
+    childProcess.stderr?.off('data', onStderr);
+    childProcess.removeAllListeners('error');
+    childProcess.removeAllListeners('close');
+  };
+
+  const earlyExit = new Promise<never>((_, reject) => {
+    childProcess.once('error', (error) => {
+      reject(
+        formatEmulatorStartupError({
+          name,
+          stdout,
+          stderr,
+          error,
+        })
+      );
+    });
+
+    childProcess.once('close', (exitCode, signal) => {
+      reject(
+        formatEmulatorStartupError({
+          name,
+          stdout,
+          stderr,
+          exitCode,
+          signal,
+        })
+      );
+    });
+  });
+
+  const observedBoot = waitForEmulator(name, startupAbortController.signal)
+    .then(() => 'booted' as const)
+    .catch((error: unknown) => {
+      if (startupAbortController.signal.aborted) {
+        return 'aborted' as const;
+      }
+
+      throw error;
+    });
+
+  const observationTimeout = wait(EMULATOR_STARTUP_OBSERVATION_TIMEOUT_MS).then(
+    () => 'timeout' as const
+  );
+
+  try {
+    await Promise.race([earlyExit, observedBoot, observationTimeout]);
+  } finally {
+    cleanup();
+  }
+
+  childProcess.stdout?.destroy();
+  childProcess.stderr?.destroy();
+  childProcess.unref();
+};
+
+export const waitForEmulator = async (
+  name: string,
+  signal: AbortSignal
+): Promise<string> => {
+  while (!signal.aborted) {
+    const adbIds = await getDeviceIds();
+
+    for (const adbId of adbIds) {
+      if (!adbId.startsWith('emulator-')) {
+        continue;
+      }
+
+      const emulatorName = await getEmulatorName(adbId);
+
+      if (emulatorName === name) {
+        return adbId;
+      }
+    }
+
+    await waitWithSignal(1000, signal);
+  }
+
+  throw signal.reason;
+};
+
+export const waitForEmulatorDisconnect = async (
+  adbId: string,
+  signal: AbortSignal
+): Promise<void> => {
+  while (!signal.aborted) {
+    const adbIds = await getDeviceIds();
+
+    if (!adbIds.includes(adbId)) {
+      return;
+    }
+
+    await waitWithSignal(1000, signal);
+  }
+
+  throw signal.reason;
+};
+
+export const waitForBoot = async (
+  name: string,
+  signal: AbortSignal
+): Promise<string> => {
+  while (!signal.aborted) {
+    const adbIds = await getDeviceIds();
+
+    for (const adbId of adbIds) {
+      if (!adbId.startsWith('emulator-')) {
+        continue;
+      }
+
+      const emulatorName = await getEmulatorName(adbId);
+
+      if (emulatorName !== name) {
+        continue;
+      }
+
+      if (await isBootCompleted(adbId)) {
+        return adbId;
+      }
+    }
+
+    await waitWithSignal(1000, signal);
+  }
+
+  throw signal.reason;
 };
 
 export const isAppRunning = async (
@@ -146,7 +552,7 @@ export const isAppRunning = async (
   bundleId: string
 ): Promise<boolean> => {
   try {
-    const { stdout } = await spawn('adb', [
+    const { stdout } = await spawn(getAdbBinaryPath(), [
       '-s',
       adbId,
       'shell',
@@ -167,7 +573,7 @@ export const getAppUid = async (
   adbId: string,
   bundleId: string
 ): Promise<number> => {
-  const { stdout } = await spawn('adb', [
+  const { stdout } = await spawn(getAdbBinaryPath(), [
     '-s',
     adbId,
     'shell',
@@ -192,7 +598,7 @@ export const setHideErrorDialogs = async (
   adbId: string,
   hide: boolean
 ): Promise<void> => {
-  await spawn('adb', [
+  await spawn(getAdbBinaryPath(), [
     '-s',
     adbId,
     'shell',
@@ -205,7 +611,7 @@ export const setHideErrorDialogs = async (
 };
 
 export const getLogcatTimestamp = async (adbId: string): Promise<string> => {
-  const { stdout } = await spawn('adb', [
+  const { stdout } = await spawn(getAdbBinaryPath(), [
     '-s',
     adbId,
     'shell',
@@ -218,7 +624,8 @@ export const getLogcatTimestamp = async (adbId: string): Promise<string> => {
 
 export const getAvds = async (): Promise<string[]> => {
   try {
-    const { stdout } = await spawn('emulator', ['-list-avds']);
+    const emulatorBinaryPath = await ensureEmulatorInstalled();
+    const { stdout } = await spawn(emulatorBinaryPath, ['-list-avds']);
     return stdout
       .split('\n')
       .map((line) => line.trim())
@@ -235,7 +642,7 @@ export type AdbDevice = {
 };
 
 export const getConnectedDevices = async (): Promise<AdbDevice[]> => {
-  const { stdout } = await spawn('adb', ['devices', '-l']);
+  const { stdout } = await spawn(getAdbBinaryPath(), ['devices', '-l']);
   const lines = stdout.split('\n').slice(1);
   const devices: AdbDevice[] = [];