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

package/src/__tests__/app-monitor.test.ts

@@ -0,0 +1,273 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+import { createAndroidAppMonitor, createAndroidLogEvent } from '../app-monitor.js';
+import * as tools from '@react-native-harness/tools';
+import { createCrashArtifactWriter } from '@react-native-harness/tools';
+
+const createMockSubprocess = (): tools.Subprocess =>
+  ({
+    nodeChildProcess: Promise.resolve({
+      kill: vi.fn(),
+    }),
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    [Symbol.asyncIterator]: async function* () {},
+  }) as unknown as tools.Subprocess;
+
+const createStreamingSubprocess = (
+  chunks: Array<{ line: string; delayMs?: number }>
+): tools.Subprocess =>
+  ({
+    nodeChildProcess: Promise.resolve({
+      kill: vi.fn(),
+    }),
+    [Symbol.asyncIterator]: async function* () {
+      for (const { line, delayMs = 0 } of chunks) {
+        if (delayMs > 0) {
+          await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+
+        yield line;
+      }
+    },
+  }) as unknown as tools.Subprocess;
+
+const artifactRoot = fs.mkdtempSync(
+  path.join(tmpdir(), 'rn-harness-android-monitor-artifacts-')
+);
+
+afterEach(() => {
+  fs.rmSync(artifactRoot, { recursive: true, force: true });
+  fs.mkdirSync(artifactRoot, { recursive: true });
+});
+
+describe('createAndroidLogEvent', () => {
+  it('extracts crash details from fatal signal log lines', () => {
+    const event = createAndroidLogEvent(
+      '03-12 11:35:08.000  1234  1234 F libc    : Fatal signal 11 (SIGSEGV), code 1 (SEGV_MAPERR) in tid 1234 (com.harnessplayground), pid 1234 (com.harnessplayground)',
+      'com.harnessplayground'
+    );
+
+    expect(event).toMatchObject({
+      type: 'possible_crash',
+      source: 'logs',
+      crashDetails: {
+        source: 'logs',
+        signal: 'SIGSEGV',
+        summary:
+          '03-12 11:35:08.000  1234  1234 F libc    : Fatal signal 11 (SIGSEGV), code 1 (SEGV_MAPERR) in tid 1234 (com.harnessplayground), pid 1234 (com.harnessplayground)',
+      },
+    });
+  });
+
+  it('extracts process and pid when AndroidRuntime reports a crash', () => {
+    const event = createAndroidLogEvent(
+      '03-12 11:35:09.000  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234',
+      'com.harnessplayground'
+    );
+
+    expect(event).toMatchObject({
+      type: 'possible_crash',
+      pid: 1234,
+      crashDetails: {
+        processName: 'com.harnessplayground',
+        pid: 1234,
+      },
+    });
+  });
+
+  it('starts logcat from the current device timestamp', async () => {
+    const spawnSpy = vi.spyOn(tools, 'spawn');
+
+    spawnSpy.mockImplementation(
+      ((file: string, args?: readonly string[]) => {
+        if (file === 'adb' && args?.includes('date')) {
+          return {
+            stdout: '03-12 11:35:08.000\n',
+          } as Awaited<ReturnType<typeof tools.spawn>>;
+        }
+
+        return createMockSubprocess();
+      }) as typeof tools.spawn
+    );
+
+    const monitor = createAndroidAppMonitor({
+      adbId: 'emulator-5554',
+      bundleId: 'com.harnessplayground',
+      appUid: 10234,
+    });
+
+    await monitor.start();
+    await monitor.stop();
+
+    expect(spawnSpy).toHaveBeenNthCalledWith(2, 'adb', [
+      '-s',
+      'emulator-5554',
+      'logcat',
+      '-v',
+      'threadtime',
+      '-b',
+      'crash',
+      '--uid=10234',
+      '-T',
+      '03-12 11:35:08.000',
+    ], {
+      stdout: 'pipe',
+      stderr: 'pipe',
+    });
+  });
+
+  it('hydrates crash details with stack lines that arrive after the first crash event', async () => {
+    const spawnSpy = vi.spyOn(tools, 'spawn');
+
+    spawnSpy.mockImplementation(
+      ((file: string, args?: readonly string[]) => {
+        if (file === 'adb' && args?.includes('date')) {
+          return {
+            stdout: '03-12 10:44:40.000\n',
+          } as Awaited<ReturnType<typeof tools.spawn>>;
+        }
+
+        return createStreamingSubprocess([
+          { line: '--------- beginning of crash' },
+          {
+            line: '03-12 10:44:40.420 13861 13861 E AndroidRuntime: Process: com.harnessplayground, PID: 13861',
+          },
+          {
+            line: '03-12 10:44:40.421 13861 13861 E AndroidRuntime: java.lang.RuntimeException: boom',
+            delayMs: 25,
+          },
+          {
+            line: '03-12 10:44:40.422 13861 13861 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
+            delayMs: 25,
+          },
+        ]);
+      }) as typeof tools.spawn
+    );
+
+    const monitor = createAndroidAppMonitor({
+      adbId: 'emulator-5554',
+      bundleId: 'com.harnessplayground',
+      appUid: 10234,
+    });
+
+    await monitor.start();
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    const details = await monitor.getCrashDetails({
+      pid: 13861,
+      occurredAt: Date.now(),
+    });
+
+    await monitor.stop();
+
+    expect(details?.rawLines).toEqual([
+      '--------- beginning of crash',
+      '03-12 10:44:40.420 13861 13861 E AndroidRuntime: Process: com.harnessplayground, PID: 13861',
+      '03-12 10:44:40.421 13861 13861 E AndroidRuntime: java.lang.RuntimeException: boom',
+      '03-12 10:44:40.422 13861 13861 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
+    ]);
+  });
+
+  it('persists resolved Android crash blocks into .harness', async () => {
+    const spawnSpy = vi.spyOn(tools, 'spawn');
+
+    spawnSpy.mockImplementation(
+      ((file: string, args?: readonly string[]) => {
+        if (file === 'adb' && args?.includes('date')) {
+          return {
+            stdout: '03-12 10:44:40.000\n',
+          } as Awaited<ReturnType<typeof tools.spawn>>;
+        }
+
+        return createStreamingSubprocess([
+          { line: '--------- beginning of crash' },
+          {
+            line: '03-12 10:44:40.420 13861 13861 E AndroidRuntime: Process: com.harnessplayground, PID: 13861',
+          },
+          {
+            line: '03-12 10:44:40.421 13861 13861 E AndroidRuntime: java.lang.RuntimeException: boom',
+            delayMs: 20,
+          },
+        ]);
+      }) as typeof tools.spawn
+    );
+
+    const monitor = createAndroidAppMonitor({
+      adbId: 'emulator-5554',
+      bundleId: 'com.harnessplayground',
+      appUid: 10234,
+      crashArtifactWriter: createCrashArtifactWriter({
+        runnerName: 'android',
+        platformId: 'android',
+        rootDir: path.join(artifactRoot, '.harness', 'crash-reports'),
+        runTimestamp: '2026-03-12T11-35-08-000Z',
+      }),
+    });
+
+    await monitor.start();
+    await new Promise((resolve) => setTimeout(resolve, 10));
+
+    const details = await monitor.getCrashDetails({
+      pid: 13861,
+      occurredAt: Date.now(),
+    });
+
+    await monitor.stop();
+
+    expect(details?.artifactPath).toContain('/.harness/crash-reports/');
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    expect(fs.readFileSync(details!.artifactPath!, 'utf8')).toContain(
+      'RuntimeException: boom'
+    );
+  });
+
+  it('can be started again after timestamp lookup fails', async () => {
+    const spawnSpy = vi.spyOn(tools, 'spawn');
+    const timestampError = new Error('date failed');
+
+    spawnSpy.mockImplementation(
+      ((file: string, args?: readonly string[]) => {
+        if (file === 'adb' && args?.includes('date')) {
+          if (
+            spawnSpy.mock.calls.filter(
+              ([calledFile, calledArgs]) =>
+                calledFile === 'adb' &&
+                Array.isArray(calledArgs) &&
+                calledArgs.includes('date')
+            ).length === 1
+          ) {
+            throw timestampError;
+          }
+
+          return {
+            stdout: '03-12 11:35:08.000\n',
+          } as Awaited<ReturnType<typeof tools.spawn>>;
+        }
+
+        return createMockSubprocess();
+      }) as typeof tools.spawn
+    );
+
+    const monitor = createAndroidAppMonitor({
+      adbId: 'emulator-5554',
+      bundleId: 'com.harnessplayground',
+      appUid: 10234,
+    });
+
+    await expect(monitor.start()).rejects.toThrow(timestampError);
+    await expect(monitor.start()).resolves.toBeUndefined();
+    await monitor.stop();
+
+    expect(
+      spawnSpy.mock.calls.some(
+        ([file, args]) =>
+          file === 'adb' &&
+          Array.isArray(args) &&
+          args.includes('logcat') &&
+          args.includes('--uid=10234')
+      )
+    ).toBe(true);
+  });
+});

package/src/__tests__/crash-parser.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+import { androidCrashParser } from '../crash-parser.js';
+
+describe('androidCrashParser.parse', () => {
+  it('parses an AndroidRuntime crash block into a crash details object', () => {
+    expect(
+      androidCrashParser.parse({
+        contents: [
+          '--------- beginning of crash',
+          '03-12 11:35:09.000  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234',
+          '03-12 11:35:09.001  1234  1234 E AndroidRuntime: java.lang.RuntimeException: boom',
+          '03-12 11:35:09.002  1234  1234 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
+        ].join('\n'),
+        bundleId: 'com.harnessplayground',
+      })
+    ).toEqual({
+      source: 'logs',
+      summary: [
+        '--------- beginning of crash',
+        '03-12 11:35:09.000  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234',
+        '03-12 11:35:09.001  1234  1234 E AndroidRuntime: java.lang.RuntimeException: boom',
+        '03-12 11:35:09.002  1234  1234 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
+      ].join('\n'),
+      signal: undefined,
+      exceptionType: 'java.lang.RuntimeException: boom',
+      processName: 'com.harnessplayground',
+      pid: 1234,
+      rawLines: [
+        '--------- beginning of crash',
+        '03-12 11:35:09.000  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234',
+        '03-12 11:35:09.001  1234  1234 E AndroidRuntime: java.lang.RuntimeException: boom',
+        '03-12 11:35:09.002  1234  1234 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
+      ],
+      stackTrace: [
+        '03-12 11:35:09.002  1234  1234 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
+      ],
+    });
+  });
+
+  it('extracts fatal signals from a native crash block', () => {
+    expect(
+      androidCrashParser.parse({
+        contents:
+          '03-12 11:35:08.000  1234  1234 F libc    : Fatal signal 11 (SIGSEGV), code 1 (SEGV_MAPERR) in tid 1234 (com.harnessplayground), pid 1234 (com.harnessplayground)',
+        bundleId: 'com.harnessplayground',
+      })
+    ).toMatchObject({
+      signal: 'SIGSEGV',
+      processName: 'com.harnessplayground',
+    });
+  });
+});

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,4 +1,47 @@
-import { spawn } from '@react-native-harness/tools';
+import { type AndroidAppLaunchOptions } from '@react-native-harness/platforms';
+import { spawn, SubprocessError } from '@react-native-harness/tools';
+
+export const getStartAppArgs = (
+  bundleId: string,
+  activityName: string,
+  options?: AndroidAppLaunchOptions
+): string[] => {
+  const args = [
+    'shell',
+    'am',
+    'start',
+    '-a',
+    'android.intent.action.MAIN',
+    '-c',
+    'android.intent.category.LAUNCHER',
+    '-n',
+    `${bundleId}/${activityName}`,
+  ];
+
+  const extras = options?.extras ?? {};
+
+  for (const [key, value] of Object.entries(extras)) {
+    if (typeof value === 'string') {
+      args.push('--es', key, value);
+      continue;
+    }
+
+    if (typeof value === 'boolean') {
+      args.push('--ez', key, value ? 'true' : 'false');
+      continue;
+    }
+
+    if (!Number.isSafeInteger(value)) {
+      throw new Error(
+        `Android app launch option "${key}" must be a safe integer.`
+      );
+    }
+
+    args.push('--ei', key, value.toString());
+  }
+
+  return args;
+};
 
 export const isAppInstalled = async (
   adbId: string,
@@ -40,21 +83,10 @@ export const stopApp = async (
 export const startApp = async (
   adbId: string,
   bundleId: string,
-  activityName: string
+  activityName: string,
+  options?: AndroidAppLaunchOptions
 ): Promise<void> => {
-  await spawn('adb', [
-    '-s',
-    adbId,
-    'shell',
-    'am',
-    'start',
-    '-a',
-    'android.intent.action.MAIN',
-    '-c',
-    'android.intent.category.LAUNCHER',
-    '-n',
-    `${bundleId}/${activityName}`,
-  ]);
+  await spawn('adb', ['-s', adbId, ...getStartAppArgs(bundleId, activityName, options)]);
 };
 
 export const getDeviceIds = async (): Promise<string[]> => {
@@ -113,14 +145,75 @@ export const isAppRunning = async (
   adbId: string,
   bundleId: string
 ): Promise<boolean> => {
+  try {
+    const { stdout } = await spawn('adb', [
+      '-s',
+      adbId,
+      'shell',
+      'pidof',
+      bundleId,
+    ]);
+    return stdout.trim() !== '';
+  } catch (error) {
+    if (error instanceof SubprocessError && error.exitCode === 1) {
+      return false;
+    }
+
+    throw error;
+  }
+};
+
+export const getAppUid = async (
+  adbId: string,
+  bundleId: string
+): Promise<number> => {
   const { stdout } = await spawn('adb', [
     '-s',
     adbId,
     'shell',
-    'pidof',
-    bundleId,
+    'pm',
+    'list',
+    'packages',
+    '-U',
   ]);
-  return stdout.trim() !== '';
+  const line = stdout
+    .split('\n')
+    .find((entry) => entry.includes(`package:${bundleId}`));
+  const match = line?.match(/\buid:(\d+)\b/);
+
+  if (!match) {
+    throw new Error(`Failed to resolve Android app UID for "${bundleId}".`);
+  }
+
+  return Number(match[1]);
+};
+
+export const setHideErrorDialogs = async (
+  adbId: string,
+  hide: boolean
+): Promise<void> => {
+  await spawn('adb', [
+    '-s',
+    adbId,
+    'shell',
+    'settings',
+    'put',
+    'global',
+    'hide_error_dialogs',
+    hide ? '1' : '0',
+  ]);
+};
+
+export const getLogcatTimestamp = async (adbId: string): Promise<string> => {
+  const { stdout } = await spawn('adb', [
+    '-s',
+    adbId,
+    'shell',
+    'date',
+    "+'%m-%d %H:%M:%S.000'",
+  ]);
+
+  return stdout.trim().replace(/^'+|'+$/g, '');
 };
 
 export const getAvds = async (): Promise<string[]> => {