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

package/src/app-monitor.ts

@@ -6,12 +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;
@@ -27,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'
   );
 
@@ -64,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],
   };
@@ -209,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,
   };
 };
 
@@ -263,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];
@@ -383,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) => {
@@ -417,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;
 
@@ -437,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')) {
-          logger.debug('Android logcat monitor stopped', error);
+        if (
+          !(error instanceof SubprocessError && error.signalName === 'SIGTERM')
+        ) {
+          androidAppMonitorLogger.debug(
+            'Android logcat monitor stopped',
+            error
+          );
         }
       }
     })();

package/src/avd-config.ts

@@ -0,0 +1,290 @@
+import { access, readFile } from 'node:fs/promises';
+import type { AndroidSystemImageArch } from './environment.js';
+import type { AndroidEmulator, AndroidEmulatorAVDConfig } from './config.js';
+
+export type AvdConfig = {
+  imageSysdir1?: string;
+  abiType?: string;
+  hwDeviceName?: string;
+  diskDataPartitionSize?: string;
+  vmHeapSize?: string;
+};
+
+export type AvdCompatibilityResult =
+  | { compatible: true }
+  | { compatible: false; reason: string };
+
+export const getAvdDirectory = (name: string): string => {
+  return `${
+    process.env.ANDROID_AVD_HOME ?? `${process.env.HOME}/.android/avd`
+  }/${name}.avd`;
+};
+
+export const getAvdConfigPath = (name: string): string => {
+  return `${getAvdDirectory(name)}/config.ini`;
+};
+
+const normalizeAvdValue = (value: string | undefined): string | undefined => {
+  if (!value) {
+    return undefined;
+  }
+
+  return value.trim();
+};
+
+const normalizeConfigValue = (value: string): string => {
+  return value.trim().toLowerCase();
+};
+
+const parseSizeInBytes = (value: string | undefined): number | null => {
+  if (!value) {
+    return null;
+  }
+
+  const normalizedValue = value.trim().toLowerCase();
+
+  if (/^\d+$/.test(normalizedValue)) {
+    return Number(normalizedValue);
+  }
+
+  const match = normalizedValue.match(/^(\d+)([kmgt])$/i);
+
+  if (!match) {
+    return null;
+  }
+
+  const size = Number(match[1]);
+  const unit = match[2]?.toLowerCase();
+
+  const multiplier =
+    unit === 'k'
+      ? 1024
+      : unit === 'm'
+      ? 1024 ** 2
+      : unit === 'g'
+      ? 1024 ** 3
+      : unit === 't'
+      ? 1024 ** 4
+      : null;
+
+  return multiplier == null ? null : size * multiplier;
+};
+
+const getApiLevelFromImageSysdir = (
+  value: string | undefined
+): number | null => {
+  const match = value?.match(/android-(\d+)/i);
+  return match ? Number(match[1]) : null;
+};
+
+const normalizeProfile = (value: string | undefined): string | undefined => {
+  if (!value) {
+    return undefined;
+  }
+
+  return value
+    .trim()
+    .replace(/[\r\n]+/g, ' ')
+    .toLowerCase();
+};
+
+export const parseAvdConfig = (contents: string): AvdConfig => {
+  const config: AvdConfig = {};
+
+  for (const line of contents.split(/\r?\n/)) {
+    const trimmedLine = line.trim();
+
+    if (trimmedLine === '' || trimmedLine.startsWith('#')) {
+      continue;
+    }
+
+    const separatorIndex = trimmedLine.indexOf('=');
+
+    if (separatorIndex === -1) {
+      continue;
+    }
+
+    const key = trimmedLine.slice(0, separatorIndex).trim();
+    const value = trimmedLine.slice(separatorIndex + 1).trim();
+
+    switch (key) {
+      case 'image.sysdir.1':
+        config.imageSysdir1 = value;
+        break;
+      case 'abi.type':
+        config.abiType = value;
+        break;
+      case 'hw.device.name':
+        config.hwDeviceName = value;
+        break;
+      case 'disk.dataPartition.size':
+        config.diskDataPartitionSize = value;
+        break;
+      case 'vm.heapSize':
+        config.vmHeapSize = value;
+        break;
+      default:
+        break;
+    }
+  }
+
+  return config;
+};
+
+export const readAvdConfig = async (
+  name: string
+): Promise<AvdConfig | null> => {
+  const configPath = getAvdConfigPath(name);
+
+  try {
+    await access(configPath);
+  } catch {
+    return null;
+  }
+
+  return parseAvdConfig(await readFile(configPath, 'utf8'));
+};
+
+export const isAvdCompatible = ({
+  emulator,
+  avdConfig,
+  hostArch,
+}: {
+  emulator: AndroidEmulator;
+  avdConfig: AvdConfig;
+  hostArch: AndroidSystemImageArch;
+}): AvdCompatibilityResult => {
+  const requestedAvdConfig = emulator.avd;
+
+  if (!requestedAvdConfig) {
+    return { compatible: false, reason: 'AVD config is required.' };
+  }
+
+  if (emulator.name.trim() === '') {
+    return { compatible: false, reason: 'AVD name is required.' };
+  }
+
+  const apiLevel = getApiLevelFromImageSysdir(avdConfig.imageSysdir1);
+
+  if (apiLevel !== requestedAvdConfig.apiLevel) {
+    return {
+      compatible: false,
+      reason: `API level mismatch: expected ${
+        requestedAvdConfig.apiLevel
+      }, got ${apiLevel ?? 'missing'}.`,
+    };
+  }
+
+  if (normalizeAvdValue(avdConfig.abiType) !== hostArch) {
+    return {
+      compatible: false,
+      reason: `ABI mismatch: expected ${hostArch}, got ${
+        normalizeAvdValue(avdConfig.abiType) ?? 'missing'
+      }.`,
+    };
+  }
+
+  if (
+    normalizeProfile(avdConfig.hwDeviceName) !==
+    normalizeProfile(requestedAvdConfig.profile)
+  ) {
+    return {
+      compatible: false,
+      reason: `Profile mismatch: expected ${requestedAvdConfig.profile}, got ${
+        avdConfig.hwDeviceName ?? 'missing'
+      }.`,
+    };
+  }
+
+  if (
+    (() => {
+      const configuredDiskSizeBytes = parseSizeInBytes(
+        avdConfig.diskDataPartitionSize
+      );
+      const requestedDiskSizeBytes = parseSizeInBytes(
+        requestedAvdConfig.diskSize
+      );
+
+      if (configuredDiskSizeBytes != null && requestedDiskSizeBytes != null) {
+        return configuredDiskSizeBytes < requestedDiskSizeBytes;
+      }
+
+      return (
+        normalizeConfigValue(avdConfig.diskDataPartitionSize ?? '') !==
+        normalizeConfigValue(requestedAvdConfig.diskSize)
+      );
+    })()
+  ) {
+    return {
+      compatible: false,
+      reason: `Disk size mismatch: expected ${
+        requestedAvdConfig.diskSize
+      }, got ${avdConfig.diskDataPartitionSize ?? 'missing'}.`,
+    };
+  }
+
+  if (
+    normalizeConfigValue(avdConfig.vmHeapSize ?? '') !==
+    normalizeConfigValue(requestedAvdConfig.heapSize)
+  ) {
+    return {
+      compatible: false,
+      reason: `Heap size mismatch: expected ${
+        requestedAvdConfig.heapSize
+      }, got ${avdConfig.vmHeapSize ?? 'missing'}.`,
+    };
+  }
+
+  return { compatible: true };
+};
+
+export const getNormalizedAvdCacheConfig = ({
+  emulator,
+  hostArch,
+}: {
+  emulator: AndroidEmulator;
+  hostArch: AndroidSystemImageArch;
+}): {
+  name: string;
+  apiLevel: number;
+  arch: AndroidSystemImageArch;
+  profile: string;
+  diskSize: string;
+  heapSize: string;
+} | null => {
+  const avd = emulator.avd;
+
+  if (!avd) {
+    return null;
+  }
+
+  return {
+    name: emulator.name,
+    apiLevel: avd.apiLevel,
+    arch: hostArch,
+    profile: avd.profile.trim().toLowerCase(),
+    diskSize: avd.diskSize.trim().toLowerCase(),
+    heapSize: avd.heapSize.trim().toLowerCase(),
+  };
+};
+
+export const resolveAvdCachingEnabled = ({
+  avd,
+  isInteractive,
+  env = process.env,
+}: {
+  avd?: AndroidEmulatorAVDConfig;
+  isInteractive: boolean;
+  env?: NodeJS.ProcessEnv;
+}): boolean => {
+  const override = env.HARNESS_AVD_CACHING;
+  const configValue = avd?.snapshot?.enabled;
+  const requestedValue =
+    override == null ? configValue : override.toLowerCase() === 'true';
+
+  if (!requestedValue) {
+    return false;
+  }
+
+  return !isInteractive;
+};

package/src/config.ts

@@ -11,6 +11,11 @@ export const AndroidEmulatorAVDConfigSchema = z.object({
   profile: z.string().min(1, 'Profile is required'),
   diskSize: z.string().min(1, 'Disk size is required').default('1G'),
   heapSize: z.string().min(1, 'Heap size is required').default('1G'),
+  snapshot: z
+    .object({
+      enabled: z.boolean().optional(),
+    })
+    .optional(),
 });
 
 export const AndroidEmulatorSchema = z.object({
@@ -51,6 +56,9 @@ export type AndroidAppLaunchOptions = z.infer<
 export type AndroidEmulatorAVDConfig = z.infer<
   typeof AndroidEmulatorAVDConfigSchema
 >;
+export type AndroidEmulatorAVDSnapshotConfig = NonNullable<
+  AndroidEmulatorAVDConfig['snapshot']
+>;
 
 export const isAndroidDeviceEmulator = (
   device: AndroidDevice

package/src/emulator-startup.ts

@@ -0,0 +1,28 @@
+export type EmulatorBootMode =
+  | 'default-boot'
+  | 'clean-snapshot-generation'
+  | 'snapshot-reuse';
+
+const COMMON_EMULATOR_ARGS = [
+  '-no-window',
+  '-gpu',
+  'swiftshader_indirect',
+  '-noaudio',
+  '-no-boot-anim',
+  '-camera-back',
+  'none',
+] as const;
+
+export const getEmulatorStartupArgs = (
+  name: string,
+  mode: EmulatorBootMode
+): string[] => {
+  const modeArgs =
+    mode === 'clean-snapshot-generation'
+      ? ['-no-snapshot-load']
+      : mode === 'snapshot-reuse'
+      ? ['-no-snapshot-save']
+      : ['-no-snapshot-load', '-no-snapshot-save'];
+
+  return [`@${name}`, ...modeArgs, ...COMMON_EMULATOR_ARGS];
+};