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

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[] = [];
 

package/src/app-monitor.ts

@@ -6,14 +6,30 @@ import {
   type AppMonitorEvent,
   type AppMonitorListener,
 } from '@react-native-harness/platforms';
-import { escapeRegExp, getEmitter, logger, spawn, SubprocessError, type Subprocess } from '@react-native-harness/tools';
+import {
+  escapeRegExp,
+  getEmitter,
+  logger,
+  spawn,
+  SubprocessError,
+  type Subprocess,
+} from '@react-native-harness/tools';
 import * as adb from './adb.js';
 import { androidCrashParser } from './crash-parser.js';
 
 const androidAppMonitorLogger = logger.child('android-app-monitor');
 
 const getLogcatArgs = (uid: number, fromTime: string) =>
-  ['logcat', '-v', 'threadtime', '-b', 'crash', `--uid=${uid}`, '-T', fromTime] as const;
+  [
+    'logcat',
+    '-v',
+    'threadtime',
+    '-b',
+    'crash',
+    `--uid=${uid}`,
+    '-T',
+    fromTime,
+  ] as const;
 const MAX_RECENT_LOG_LINES = 200;
 const MAX_RECENT_CRASH_ARTIFACTS = 10;
 const CRASH_ARTIFACT_SETTLE_DELAY_MS = 100;
@@ -29,7 +45,9 @@ const nativeCrashPattern = (bundleId: string) =>
 
 const processDiedPattern = (bundleId: string) =>
   new RegExp(
-    `Process\\s+${escapeRegExp(bundleId)}\\s+\\(pid\\s+(\\d+)\\)\\s+has\\s+died`,
+    `Process\\s+${escapeRegExp(
+      bundleId
+    )}\\s+\\(pid\\s+(\\d+)\\)\\s+has\\s+died`,
     'i'
   );
 
@@ -66,7 +84,11 @@ const getAndroidLogLineCrashDetails = ({
     summary: line.trim(),
     signal: getSignal(line),
     exceptionType: fatalExceptionMatch?.[1]?.trim(),
-    processName: processMatch ? bundleId : line.includes(bundleId) ? bundleId : undefined,
+    processName: processMatch
+      ? bundleId
+      : line.includes(bundleId)
+      ? bundleId
+      : undefined,
     pid: pid ?? (processMatch ? Number(processMatch[1]) : undefined),
     rawLines: [line],
   };
@@ -211,7 +233,9 @@ const createCrashArtifact = ({
     triggerOccurredAt,
     artifactType: 'logcat',
     rawLines:
-      rawLines.length > 0 ? rawLines : parsedDetails.rawLines ?? details.rawLines,
+      rawLines.length > 0
+        ? rawLines
+        : parsedDetails.rawLines ?? details.rawLines,
   };
 };
 
@@ -265,11 +289,12 @@ const getLatestCrashArtifact = ({
     matchingByPid.length > 0
       ? matchingByPid
       : matchingByProcess.length > 0
-        ? matchingByProcess
-        : crashArtifacts;
+      ? matchingByProcess
+      : crashArtifacts;
   const sortedCandidates = [...candidates].sort(
     (left, right) =>
-      Math.abs(left.occurredAt - occurredAt) - Math.abs(right.occurredAt - occurredAt)
+      Math.abs(left.occurredAt - occurredAt) -
+      Math.abs(right.occurredAt - occurredAt)
   );
 
   const artifact = sortedCandidates[0];
@@ -385,9 +410,10 @@ export const createAndroidAppMonitor = ({
   };
 
   const recordLogLine = (line: string) => {
-    recentLogLines = [...recentLogLines, { line, occurredAt: Date.now() }].slice(
-      -MAX_RECENT_LOG_LINES
-    );
+    recentLogLines = [
+      ...recentLogLines,
+      { line, occurredAt: Date.now() },
+    ].slice(-MAX_RECENT_LOG_LINES);
   };
 
   const recordCrashArtifact = (details?: AppCrashDetails) => {
@@ -419,10 +445,14 @@ export const createAndroidAppMonitor = ({
   const startLogcat = async () => {
     const logcatTimestamp = await adb.getLogcatTimestamp(adbId);
 
-    logcatProcess = spawn('adb', ['-s', adbId, ...getLogcatArgs(appUid, logcatTimestamp)], {
-      stdout: 'pipe',
-      stderr: 'pipe',
-    });
+    logcatProcess = spawn(
+      'adb',
+      ['-s', adbId, ...getLogcatArgs(appUid, logcatTimestamp)],
+      {
+        stdout: 'pipe',
+        stderr: 'pipe',
+      }
+    );
 
     const currentProcess = logcatProcess;
 
@@ -439,15 +469,23 @@ export const createAndroidAppMonitor = ({
           const event = createAndroidLogEvent(line, bundleId);
 
           if (event) {
-            if (event.type === 'possible_crash' || event.type === 'app_exited') {
+            if (
+              event.type === 'possible_crash' ||
+              event.type === 'app_exited'
+            ) {
               recordCrashArtifact(event.crashDetails);
             }
             emit(event);
           }
         }
       } catch (error) {
-        if (!(error instanceof SubprocessError && error.signalName === 'SIGTERM')) {
-          androidAppMonitorLogger.debug('Android logcat monitor stopped', error);
+        if (
+          !(error instanceof SubprocessError && error.signalName === 'SIGTERM')
+        ) {
+          androidAppMonitorLogger.debug(
+            'Android logcat monitor stopped',
+            error
+          );
         }
       }
     })();