@react-native-harness/platform-android 1.3.0 → 1.4.0

package/src/app-session.ts

@@ -0,0 +1,316 @@
+import {
+  createAppSessionEmitter,
+  createBoundedLogBuffer,
+  type AppSession,
+  type AppSessionState,
+  type CrashArtifactWriter,
+} from '@react-native-harness/platforms';
+import {
+  escapeRegExp,
+  logger,
+  type Subprocess,
+} from '@react-native-harness/tools';
+import { createAndroidCrashReporter } from './crash-reporter.js';
+
+const androidAppSessionLogger = logger.child('android-app-session');
+const APP_EXIT_POLL_INTERVAL_MS = 1000;
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const getLogcatArgs = (appUid: number, fromTime: string) =>
+  [
+    'logcat',
+    '-v',
+    'threadtime',
+    '-b',
+    'crash',
+    `--uid=${appUid}`,
+    '-T',
+    fromTime,
+  ] as const;
+
+const getProcessPattern = (bundleId: string) =>
+  new RegExp(`Process:\\s*${escapeRegExp(bundleId)},\\s*PID:\\s*(\\d+)`);
+
+const getStartProcPattern = (bundleId: string) =>
+  new RegExp(`Start proc (\\d+):${escapeRegExp(bundleId)}(?:/|\\s)`);
+
+const getProcessDiedPattern = (bundleId: string) =>
+  new RegExp(
+    `Process\\s+${escapeRegExp(
+      bundleId
+    )}\\s+\\(pid\\s+(\\d+)\\)\\s+has\\s+died`,
+    'i'
+  );
+
+const getObservedPid = (line: string, bundleId: string): number | undefined => {
+  const match =
+    line.match(getProcessPattern(bundleId)) ??
+    line.match(getStartProcPattern(bundleId)) ??
+    line.match(getProcessDiedPattern(bundleId));
+
+  return match?.[1] ? Number(match[1]) : undefined;
+};
+
+const isCrashSignal = (line: string, bundleId: string): boolean => {
+  return (
+    getProcessPattern(bundleId).test(line) ||
+    new RegExp(`>>>\\s*${escapeRegExp(bundleId)}\\s*<<<`).test(line) ||
+    getProcessDiedPattern(bundleId).test(line) ||
+    (line.includes(bundleId) &&
+      /fatal|crash|signal 11|signal 6|backtrace/i.test(line))
+  );
+};
+
+const isExitedState = (
+  state: AppSessionState
+): state is Extract<AppSessionState, { status: 'exited' }> =>
+  state.status === 'exited';
+
+type CreateAndroidAppSessionOptions = {
+  appUid: number;
+  bundleId: string;
+  startApp: () => Promise<void>;
+  stopApp: () => Promise<void>;
+  getAppPid: () => Promise<number | null>;
+  getLogcatTimestamp: () => Promise<string>;
+  startLogcat: (
+    args: readonly string[],
+    options: { signal: AbortSignal }
+  ) => Subprocess;
+  getDropboxOutput?: () => Promise<string>;
+  getExitInfo?: () => Promise<string>;
+  crashArtifactWriter?: CrashArtifactWriter;
+  /**
+   * Session-lifetime abort signal (see HarnessPlatformInitOptions.signal).
+   * Combined with the app session's own logcatAbortController so that
+   * aborting the session stops the logcat stream even if dispose() hasn't
+   * been called yet (e.g. SIGTERM during teardown of other resources).
+   */
+  signal?: AbortSignal;
+};
+
+export const createAndroidAppSession = async ({
+  appUid,
+  bundleId,
+  startApp,
+  stopApp,
+  getAppPid,
+  getLogcatTimestamp,
+  startLogcat,
+  getDropboxOutput,
+  getExitInfo,
+  crashArtifactWriter,
+  signal,
+}: CreateAndroidAppSessionOptions): Promise<AppSession> => {
+  const emitter = createAppSessionEmitter();
+  const logBuffer = createBoundedLogBuffer();
+  let state: AppSessionState = { status: 'running' };
+  let disposed = false;
+  let stopPolling = false;
+  let hasObservedProcess = false;
+  let exitNotification: ReturnType<typeof setTimeout> | null = null;
+  let pollDelayTimeout: ReturnType<typeof setTimeout> | null = null;
+  let resolvePollDelay: (() => void) | null = null;
+
+  const getCurrentPid = () => ('pid' in state ? state.pid : undefined);
+
+  const setRunning = (pid?: number) => {
+    if (disposed || state.status === 'disposed' || state.status === 'exited') {
+      return;
+    }
+
+    if (pid !== undefined) {
+      hasObservedProcess = true;
+    }
+
+    state =
+      pid === undefined ? { status: 'running' } : { status: 'running', pid };
+  };
+
+  const scheduleExitNotification = () => {
+    if (exitNotification) {
+      return;
+    }
+
+    exitNotification = setTimeout(() => {
+      exitNotification = null;
+
+      if (!disposed && state.status === 'exited') {
+        emitter.emit({ type: 'app_exited' });
+      }
+    }, 0);
+  };
+
+  const waitForNextPoll = () =>
+    new Promise<void>((resolve) => {
+      resolvePollDelay = () => {
+        resolvePollDelay = null;
+        pollDelayTimeout = null;
+        resolve();
+      };
+
+      pollDelayTimeout = setTimeout(() => {
+        resolvePollDelay?.();
+      }, APP_EXIT_POLL_INTERVAL_MS);
+    });
+
+  const cancelPendingPollDelay = () => {
+    if (pollDelayTimeout) {
+      clearTimeout(pollDelayTimeout);
+      pollDelayTimeout = null;
+    }
+
+    resolvePollDelay?.();
+  };
+
+  const setExited = (
+    reason: 'observed-exit' | 'process-gone',
+    pid?: number
+  ) => {
+    if (disposed || state.status === 'disposed' || state.status === 'exited') {
+      return;
+    }
+
+    state = {
+      status: 'exited',
+      occurredAt: Date.now(),
+      pid: pid ?? getCurrentPid(),
+      reason,
+    };
+    scheduleExitNotification();
+  };
+
+  const setExitedPid = (pid: number) => {
+    if (state.status !== 'exited' || state.pid !== undefined) {
+      return;
+    }
+
+    state = {
+      status: 'exited',
+      occurredAt: state.occurredAt,
+      reason: state.reason,
+      pid,
+    };
+  };
+
+  const logcatTimestamp = await getLogcatTimestamp();
+  const sessionStartedAt = Date.now();
+  const logcatAbortController = new AbortController();
+  const logcatSignal = signal
+    ? AbortSignal.any([signal, logcatAbortController.signal])
+    : logcatAbortController.signal;
+  const logcatProcess = startLogcat(getLogcatArgs(appUid, logcatTimestamp), {
+    signal: logcatSignal,
+  });
+  // Aborting is nano-spawn's own cancellation path, so the resulting
+  // SubprocessError is settled the same way regardless of which of the
+  // merged stdout/stderr iterators observes it first. Without this, killing
+  // the underlying process directly can make both iterators reject at once,
+  // and nano-spawn's internal `Promise.race` only reports one of them,
+  // leaving the other an unhandled rejection.
+  logcatProcess.catch(() => undefined);
+  const crashReporter = createAndroidCrashReporter({
+    bundleId,
+    crashArtifactWriter,
+    getLogs: () => logBuffer.getLogs(),
+    getDropboxOutput,
+    getExitInfo,
+    minOccurredAt: sessionStartedAt,
+  });
+
+  const logTask = (async () => {
+    try {
+      for await (const rawLine of logcatProcess) {
+        const line = String(rawLine);
+
+        if (!disposed) {
+          logBuffer.push(line);
+        }
+
+        const observedPid = getObservedPid(line, bundleId);
+
+        if (observedPid !== undefined) {
+          if (state.status === 'running') {
+            setRunning(observedPid);
+          } else {
+            setExitedPid(observedPid);
+          }
+        }
+
+        if (state.status === 'running' && isCrashSignal(line, bundleId)) {
+          setExited('observed-exit', observedPid);
+        }
+      }
+    } catch (error) {
+      if (!disposed) {
+        androidAppSessionLogger.debug('Android logcat stream stopped', error);
+      }
+    }
+  })();
+
+  try {
+    await startApp();
+  } catch (error) {
+    disposed = true;
+    stopPolling = true;
+    emitter.clear();
+    logcatAbortController.abort();
+    await Promise.allSettled([logTask]);
+    throw error;
+  }
+
+  const pollTask = (async () => {
+    await sleep(0);
+
+    while (!stopPolling) {
+      if (isExitedState(state)) {
+        return;
+      }
+
+      try {
+        const pid = await getAppPid();
+
+        if (pid != null) {
+          setRunning(pid);
+        } else if (hasObservedProcess) {
+          setExited('process-gone');
+          return;
+        }
+      } catch (error) {
+        androidAppSessionLogger.debug('Android app session poll failed', error);
+      }
+
+      await waitForNextPoll();
+    }
+  })();
+
+  return {
+    dispose: async () => {
+      if (disposed) {
+        return;
+      }
+
+      disposed = true;
+      stopPolling = true;
+      state = { status: 'disposed', occurredAt: Date.now() };
+
+      if (exitNotification) {
+        clearTimeout(exitNotification);
+        exitNotification = null;
+      }
+
+      cancelPendingPollDelay();
+
+      emitter.clear();
+      logcatAbortController.abort();
+      await stopApp();
+      await Promise.allSettled([logTask, pollTask]);
+    },
+    getState: async () => state,
+    getLogs: () => logBuffer.getLogs(),
+    getCrashDetails: crashReporter.getCrashDetails,
+    addListener: emitter.addListener,
+    removeListener: emitter.removeListener,
+  };
+};

package/src/avd-config.ts

@@ -1,6 +1,7 @@
 import { access, readFile } from 'node:fs/promises';
 import type { AndroidSystemImageArch } from './environment.js';
 import type { AndroidEmulator, AndroidEmulatorAVDConfig } from './config.js';
+import { getEmulatorCpuCores } from './emulator-startup.js';
 
 export type AvdConfig = {
   imageSysdir1?: string;
@@ -8,6 +9,7 @@ export type AvdConfig = {
   hwDeviceName?: string;
   diskDataPartitionSize?: string;
   vmHeapSize?: string;
+  hwCpuNcore?: string;
 };
 
 export type AvdCompatibilityResult =
@@ -123,6 +125,9 @@ export const parseAvdConfig = (contents: string): AvdConfig => {
       case 'vm.heapSize':
         config.vmHeapSize = value;
         break;
+      case 'hw.cpu.ncore':
+        config.hwCpuNcore = value;
+        break;
       default:
         break;
     }
@@ -235,6 +240,18 @@ export const isAvdCompatible = ({
     };
   }
 
+  if (
+    normalizeConfigValue(avdConfig.hwCpuNcore ?? '') !==
+    normalizeConfigValue(String(getEmulatorCpuCores()))
+  ) {
+    return {
+      compatible: false,
+      reason: `CPU core count mismatch: expected ${getEmulatorCpuCores()}, got ${
+        avdConfig.hwCpuNcore ?? 'missing'
+      }.`,
+    };
+  }
+
   return { compatible: true };
 };