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

package/dist/crash-reporter.js

@@ -0,0 +1,150 @@
+import { androidCrashParser } from './crash-parser.js';
+import { collectExitInfoArtifact, waitForDropboxArtifacts, getBestDropboxArtifact, } from './crash-diagnostics.js';
+const CRASH_ARTIFACT_SETTLE_DELAY_MS = 100;
+const CRASH_BLOCK_HEADER = '--------- beginning of crash';
+const CRASH_LOG_WINDOW_MS = 5000;
+const findCrashBlockStart = (lines) => {
+    let latestCrashHeaderIndex = -1;
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        if (/FATAL EXCEPTION:|Process:\s+.+,\s+PID:|>>>\s+.+\s+<<</i.test(lines[index])) {
+            latestCrashHeaderIndex = index;
+            break;
+        }
+    }
+    const latestBlockHeaderIndex = lines.lastIndexOf(CRASH_BLOCK_HEADER);
+    return latestBlockHeaderIndex >= 0
+        ? latestBlockHeaderIndex
+        : latestCrashHeaderIndex;
+};
+const getCrashBlock = (logs, occurredAt) => {
+    const nearbyLogs = logs.filter((log) => Math.abs(log.occurredAt - occurredAt) <= CRASH_LOG_WINDOW_MS);
+    const lines = nearbyLogs.length > 0
+        ? nearbyLogs.map((log) => log.line)
+        : logs.map((log) => log.line);
+    const blockStart = findCrashBlockStart(lines);
+    return blockStart >= 0 ? lines.slice(blockStart) : lines;
+};
+const hasUsefulLogcatBlock = (rawLines) => rawLines.some((line) => /FATAL EXCEPTION:|Process:\s+.+,\s+PID:|>>>\s+.+\s+<<</i.test(line));
+const getLogcatCrashDetails = ({ rawLines, bundleId, pid, }) => ({
+    ...androidCrashParser.parse({
+        contents: rawLines.join('\n'),
+        bundleId,
+        pid,
+    }),
+    artifactType: 'logcat',
+    rawLines,
+});
+const persistLogcatArtifact = ({ details, crashArtifactWriter, testFilePath, }) => {
+    if (!crashArtifactWriter || !details.rawLines?.length) {
+        return details;
+    }
+    return {
+        ...details,
+        artifactPath: crashArtifactWriter.persistArtifact({
+            artifactKind: 'logcat',
+            testFilePath,
+            source: {
+                kind: 'text',
+                fileName: 'logcat.txt',
+                text: `${details.rawLines.join('\n')}\n`,
+            },
+        }),
+    };
+};
+const getDropboxFallbackDetails = (artifact) => ({
+    ...artifact,
+    artifactType: artifact.artifactType,
+    artifactPath: artifact.artifactPath,
+});
+const getEnrichmentArtifacts = async ({ bundleId, crashArtifactWriter, getDropboxOutput, getExitInfo, minOccurredAt, occurredAt, pid, testFilePath, }) => {
+    const dropboxArtifacts = getDropboxOutput
+        ? await waitForDropboxArtifacts({
+            bundleId,
+            crashArtifactWriter,
+            getDropboxOutput,
+            minOccurredAt,
+            occurredAt,
+            pid,
+            testFilePath,
+        })
+        : [];
+    const enrichmentArtifacts = dropboxArtifacts
+        .filter((artifact) => artifact.artifactPath !== undefined)
+        .map((artifact) => ({
+        artifactType: artifact.artifactType,
+        artifactPath: artifact.artifactPath,
+    }));
+    if (getExitInfo) {
+        const exitInfoArtifact = await collectExitInfoArtifact({
+            bundleId,
+            crashArtifactWriter,
+            getExitInfo,
+            pid,
+            testFilePath,
+        });
+        if (exitInfoArtifact?.artifactPath.startsWith('/')) {
+            enrichmentArtifacts.push({
+                artifactType: exitInfoArtifact.artifactType,
+                artifactPath: exitInfoArtifact.artifactPath,
+            });
+        }
+    }
+    return { dropboxArtifacts, enrichmentArtifacts };
+};
+export const createAndroidCrashReporter = ({ bundleId, crashArtifactWriter, getLogs, getDropboxOutput, getExitInfo, minOccurredAt, }) => ({
+    getCrashDetails: async ({ occurredAt, pid, testFilePath, }) => {
+        await new Promise((resolve) => setTimeout(resolve, CRASH_ARTIFACT_SETTLE_DELAY_MS));
+        const rawLines = getCrashBlock(getLogs(), occurredAt);
+        const logcatDetails = rawLines.length > 0
+            ? getLogcatCrashDetails({ rawLines, bundleId, pid })
+            : null;
+        let enrichmentArtifacts = [];
+        let dropboxArtifacts = [];
+        if (getDropboxOutput || getExitInfo) {
+            ({ dropboxArtifacts, enrichmentArtifacts } =
+                await getEnrichmentArtifacts({
+                    bundleId,
+                    crashArtifactWriter,
+                    getDropboxOutput,
+                    getExitInfo,
+                    minOccurredAt,
+                    occurredAt,
+                    pid,
+                    testFilePath,
+                }));
+        }
+        if (logcatDetails && hasUsefulLogcatBlock(rawLines)) {
+            return {
+                ...persistLogcatArtifact({
+                    details: logcatDetails,
+                    crashArtifactWriter,
+                    testFilePath,
+                }),
+                enrichmentArtifacts: enrichmentArtifacts.length > 0 ? enrichmentArtifacts : undefined,
+            };
+        }
+        const dropboxFallback = getBestDropboxArtifact(dropboxArtifacts);
+        if (dropboxFallback) {
+            const primary = getDropboxFallbackDetails(dropboxFallback);
+            return {
+                ...primary,
+                enrichmentArtifacts: enrichmentArtifacts.filter((artifact) => artifact.artifactPath !== primary.artifactPath),
+            };
+        }
+        if (logcatDetails) {
+            return {
+                ...persistLogcatArtifact({
+                    details: logcatDetails,
+                    crashArtifactWriter,
+                    testFilePath,
+                }),
+                enrichmentArtifacts: enrichmentArtifacts.length > 0 ? enrichmentArtifacts : undefined,
+            };
+        }
+        return enrichmentArtifacts.length > 0
+            ? {
+                enrichmentArtifacts,
+            }
+            : null;
+    },
+});

package/dist/emulator-startup.d.ts

@@ -1,3 +1,26 @@
 export type EmulatorBootMode = 'default-boot' | 'clean-snapshot-generation' | 'snapshot-reuse';
+/**
+ * Returns the vCPU count baked into an AVD for this runner.
+ *
+ * AVD snapshots require an identical hardware configuration to load, so all
+ * AVD creation, compatibility, and cache-key callers must use this value on
+ * the same host.
+ */
+export declare const getEmulatorCpuCores: () => number;
 export declare const getEmulatorStartupArgs: (name: string, mode: EmulatorBootMode) => string[];
+/**
+ * Parses the output of `emulator -accel-check` to determine whether
+ * hardware acceleration (KVM on Linux, HVF on macOS) is usable. The
+ * emulator prints a message containing "is installed and usable" when
+ * acceleration is available.
+ */
+export declare const isAccelerationUsable: (accelCheckOutput: string) => boolean;
+/**
+ * Runs `emulator -accel-check` and logs a non-fatal warning when hardware
+ * acceleration (KVM/HVF) appears unavailable, in which case the emulator
+ * falls back to very slow software emulation. This check must never fail or
+ * block emulator startup - any error running it is swallowed and only
+ * debug-logged.
+ */
+export declare const warnIfEmulatorAccelerationUnavailable: () => Promise<void>;
 //# sourceMappingURL=emulator-startup.d.ts.map

package/dist/emulator-startup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"emulator-startup.d.ts","sourceRoot":"","sources":["../src/emulator-startup.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GACxB,cAAc,GACd,2BAA2B,GAC3B,gBAAgB,CAAC;AAUrB,eAAO,MAAM,sBAAsB,GACjC,MAAM,MAAM,EACZ,MAAM,gBAAgB,KACrB,MAAM,EASR,CAAC"}
+{"version":3,"file":"emulator-startup.d.ts","sourceRoot":"","sources":["../src/emulator-startup.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,gBAAgB,GACxB,cAAc,GACd,2BAA2B,GAC3B,gBAAgB,CAAC;AAErB;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,QAAO,MAEtC,CAAC;AAWF,eAAO,MAAM,sBAAsB,GACjC,MAAM,MAAM,EACZ,MAAM,gBAAgB,KACrB,MAAM,EASR,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,kBAAkB,MAAM,KAAG,OAE/D,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,qCAAqC,QACtC,OAAO,CAAC,IAAI,CA+BrB,CAAC"}

package/dist/emulator-startup.js

@@ -1,9 +1,24 @@
+import { getDeviceCoreBudget, logger, spawn, SubprocessError, } from '@react-native-harness/tools';
+import os from 'node:os';
+import { getEmulatorBinaryPath } from './environment.js';
+const emulatorStartupLogger = logger.child('android-emulator-startup');
+/**
+ * Returns the vCPU count baked into an AVD for this runner.
+ *
+ * AVD snapshots require an identical hardware configuration to load, so all
+ * AVD creation, compatibility, and cache-key callers must use this value on
+ * the same host.
+ */
+export const getEmulatorCpuCores = () => {
+    return getDeviceCoreBudget(os.availableParallelism());
+};
 const COMMON_EMULATOR_ARGS = [
     '-no-window',
     '-gpu',
     'swiftshader_indirect',
     '-noaudio',
     '-no-boot-anim',
+    '-no-metrics',
 ];
 export const getEmulatorStartupArgs = (name, mode) => {
     const modeArgs = mode === 'clean-snapshot-generation'
@@ -13,3 +28,46 @@ export const getEmulatorStartupArgs = (name, mode) => {
             : ['-no-snapshot-load', '-no-snapshot-save'];
     return [`@${name}`, ...modeArgs, ...COMMON_EMULATOR_ARGS];
 };
+/**
+ * Parses the output of `emulator -accel-check` to determine whether
+ * hardware acceleration (KVM on Linux, HVF on macOS) is usable. The
+ * emulator prints a message containing "is installed and usable" when
+ * acceleration is available.
+ */
+export const isAccelerationUsable = (accelCheckOutput) => {
+    return accelCheckOutput.includes('is installed and usable');
+};
+/**
+ * Runs `emulator -accel-check` and logs a non-fatal warning when hardware
+ * acceleration (KVM/HVF) appears unavailable, in which case the emulator
+ * falls back to very slow software emulation. This check must never fail or
+ * block emulator startup - any error running it is swallowed and only
+ * debug-logged.
+ */
+export const warnIfEmulatorAccelerationUnavailable = async () => {
+    let combinedOutput;
+    try {
+        const emulatorBinaryPath = getEmulatorBinaryPath();
+        const { stdout, stderr } = await spawn(emulatorBinaryPath, [
+            '-accel-check',
+        ]);
+        combinedOutput = `${stdout}\n${stderr}`;
+    }
+    catch (error) {
+        if (error instanceof SubprocessError) {
+            // The check itself ran but exited non-zero - this is how
+            // `-accel-check` reports that acceleration is unavailable, so treat
+            // its output as a normal (non-fatal) result rather than swallowing it.
+            combinedOutput = `${error.stdout}\n${error.stderr}`;
+        }
+        else {
+            // Failed to even run the check (e.g. binary missing). This must never
+            // fail or block emulator startup.
+            emulatorStartupLogger.debug('Failed to run "emulator -accel-check": %o', error);
+            return;
+        }
+    }
+    if (!isAccelerationUsable(combinedOutput)) {
+        logger.warn('Hardware acceleration (KVM/HVF) appears unavailable for the Android emulator. It will fall back to very slow software emulation.');
+    }
+};

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export { androidEmulator, physicalAndroidDevice, androidPlatform, } from './fact
 export type { AndroidPlatformConfig } from './config.js';
 export { getNormalizedAvdCacheConfig, resolveAvdCachingEnabled, } from './avd-config.js';
 export { getHostAndroidSystemImageArch } from './environment.js';
+export { getEmulatorCpuCores } from './emulator-startup.js';
 export { HarnessAppPathError, HarnessEmulatorConfigError } from './errors.js';
 export { getRunTargets } from './targets.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EACL,2BAA2B,EAC3B,wBAAwB,GACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EACL,2BAA2B,EAC3B,wBAAwB,GACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -1,5 +1,6 @@
 export { androidEmulator, physicalAndroidDevice, androidPlatform, } from './factory.js';
 export { getNormalizedAvdCacheConfig, resolveAvdCachingEnabled, } from './avd-config.js';
 export { getHostAndroidSystemImageArch } from './environment.js';
+export { getEmulatorCpuCores } from './emulator-startup.js';
 export { HarnessAppPathError, HarnessEmulatorConfigError } from './errors.js';
 export { getRunTargets } from './targets.js';

package/dist/instance.d.ts

@@ -2,5 +2,5 @@ import { type HarnessPlatformInitOptions, HarnessPlatformRunner } from '@react-n
 import type { Config as HarnessConfig } from '@react-native-harness/config';
 import { AndroidPlatformConfig } from './config.js';
 export declare const getAndroidEmulatorPlatformInstance: (config: AndroidPlatformConfig, harnessConfig: HarnessConfig, init: HarnessPlatformInitOptions) => Promise<HarnessPlatformRunner>;
-export declare const getAndroidPhysicalDevicePlatformInstance: (config: AndroidPlatformConfig, harnessConfig: HarnessConfig) => Promise<HarnessPlatformRunner>;
+export declare const getAndroidPhysicalDevicePlatformInstance: (config: AndroidPlatformConfig, harnessConfig: HarnessConfig, init?: HarnessPlatformInitOptions) => Promise<HarnessPlatformRunner>;
 //# sourceMappingURL=instance.d.ts.map

package/dist/instance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../src/instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,0BAA0B,EAC/B,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE5E,OAAO,EACL,qBAAqB,EAGtB,MAAM,aAAa,CAAC;AAgLrB,eAAO,MAAM,kCAAkC,GAC7C,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,EAC5B,MAAM,0BAA0B,KAC/B,OAAO,CAAC,qBAAqB,CA2I/B,CAAC;AAEF,eAAO,MAAM,wCAAwC,GACnD,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,KAC3B,OAAO,CAAC,qBAAqB,CAsE/B,CAAC"}
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../src/instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,0BAA0B,EAC/B,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE5E,OAAO,EACL,qBAAqB,EAGtB,MAAM,aAAa,CAAC;AAyKrB,eAAO,MAAM,kCAAkC,GAC7C,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,EAC5B,MAAM,0BAA0B,KAC/B,OAAO,CAAC,qBAAqB,CAoI/B,CAAC;AAEF,eAAO,MAAM,wCAAwC,GACnD,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,EAC5B,OAAO,0BAA0B,KAChC,OAAO,CAAC,qBAAqB,CA+D/B,CAAC"}

package/dist/instance.js

@@ -1,24 +1,18 @@
 import { AppNotInstalledError, DeviceNotFoundError, } from '@react-native-harness/platforms';
-import { logger } from '@react-native-harness/tools';
+import { instrumented, logger, noopDiagnostics } from '@react-native-harness/tools';
 import { assertAndroidDeviceEmulator, assertAndroidDevicePhysical, } from './config.js';
 import { isAvdCompatible, readAvdConfig, resolveAvdCachingEnabled, } from './avd-config.js';
 import { getAdbId } from './adb-id.js';
-import * as adb from './adb.js';
+import * as adbModule from './adb.js';
 import { applyHarnessDebugHttpHost, clearHarnessDebugHttpHost, } from './shared-prefs.js';
 import { getDeviceName } from './utils.js';
-import { createAndroidAppMonitor } from './app-monitor.js';
 import { HarnessAppPathError, HarnessEmulatorConfigError } from './errors.js';
 import { ensureAndroidEmulatorAvailable, ensureAndroidEmulatorEnvironment, getHostAndroidSystemImageArch, } from './environment.js';
+import { warnIfEmulatorAccelerationUnavailable } from './emulator-startup.js';
 import { isInteractive } from '@react-native-harness/tools';
 import fs from 'node:fs';
+import { createAndroidAppSession } from './app-session.js';
 const androidInstanceLogger = logger.child('android-instance');
-const createNoopAppMonitor = () => ({
-    start: async () => undefined,
-    stop: async () => undefined,
-    dispose: async () => undefined,
-    addListener: () => undefined,
-    removeListener: () => undefined,
-});
 const getHarnessAppPath = () => {
     const appPath = process.env.HARNESS_APP_PATH;
     if (!appPath) {
@@ -42,23 +36,24 @@ const getOptionalHarnessAppPath = () => {
 const configureAndroidRuntime = async (adbId, config, harnessConfig) => {
     const metroPort = harnessConfig.metroPort;
     await Promise.all([
-        adb.reversePort(adbId, metroPort),
-        adb.reversePort(adbId, 8080),
-        adb.setHideErrorDialogs(adbId, true),
+        adbModule.reversePort(adbId, metroPort),
+        adbModule.reversePort(adbId, 8080),
+        adbModule.setHideErrorDialogs(adbId, true),
         applyHarnessDebugHttpHost(adbId, config.bundleId, `localhost:${metroPort}`),
     ]);
-    return adb.getAppUid(adbId, config.bundleId);
+    return adbModule.getAppUid(adbId, config.bundleId);
 };
 const startAndWaitForBoot = async ({ emulatorName, signal, mode, }) => {
     await ensureAndroidEmulatorAvailable();
-    await adb.startEmulator(emulatorName, mode);
-    return adb.waitForBoot(emulatorName, signal);
+    await warnIfEmulatorAccelerationUnavailable();
+    await adbModule.startEmulator(emulatorName, mode);
+    return adbModule.waitForBoot(emulatorName, signal);
 };
 const recreateAvd = async ({ emulatorConfig, }) => {
     if (!emulatorConfig.avd) {
         throw new HarnessEmulatorConfigError(emulatorConfig.name);
     }
-    await adb.createAvd({
+    await adbModule.createAvd({
         name: emulatorConfig.name,
         apiLevel: emulatorConfig.avd.apiLevel,
         profile: emulatorConfig.avd.profile,
@@ -69,7 +64,7 @@ const recreateAvd = async ({ emulatorConfig, }) => {
 const prepareCachedAvd = async ({ emulatorConfig, signal, }) => {
     const emulatorName = emulatorConfig.name;
     const hostArch = getHostAndroidSystemImageArch();
-    const hasExistingAvd = await adb.hasAvd(emulatorName);
+    const hasExistingAvd = await adbModule.hasAvd(emulatorName);
     const avdConfig = hasExistingAvd ? await readAvdConfig(emulatorName) : null;
     const compatibility = avdConfig == null
         ? { compatible: false, reason: 'Missing AVD config.ini.' }
@@ -84,7 +79,7 @@ const prepareCachedAvd = async ({ emulatorConfig, signal, }) => {
             : 'Creating Android emulator %s...', emulatorName);
         if (hasExistingAvd && !compatibility.compatible) {
             androidInstanceLogger.debug('Android AVD %s is not reusable: %s', emulatorName, compatibility.reason);
-            await adb.deleteAvd(emulatorName);
+            await adbModule.deleteAvd(emulatorName);
         }
         await recreateAvd({ emulatorConfig });
         const generationAdbId = await startAndWaitForBoot({
@@ -93,8 +88,8 @@ const prepareCachedAvd = async ({ emulatorConfig, signal, }) => {
             mode: 'clean-snapshot-generation',
         });
         logger.info('Saving Android emulator snapshot for %s...', emulatorName);
-        await adb.stopEmulator(generationAdbId);
-        await adb.waitForEmulatorDisconnect(generationAdbId, signal);
+        await adbModule.stopEmulator(generationAdbId);
+        await adbModule.waitForEmulatorDisconnect(generationAdbId, signal);
     }
     else {
         logger.info('Using cached Android emulator %s...', emulatorName);
@@ -107,7 +102,7 @@ const prepareCachedAvd = async ({ emulatorConfig, signal, }) => {
 };
 export const getAndroidEmulatorPlatformInstance = async (config, harnessConfig, init) => {
     assertAndroidDeviceEmulator(config.device);
-    const detectNativeCrashes = harnessConfig.detectNativeCrashes ?? true;
+    const adb = instrumented(adbModule, 'platform.android.adb', init.diagnostics ?? noopDiagnostics);
     const permissionsEnabled = harnessConfig.permissions ?? false;
     const emulatorConfig = config.device;
     const emulatorName = emulatorConfig.name;
@@ -166,17 +161,23 @@ export const getAndroidEmulatorPlatformInstance = async (config, harnessConfig,
         await adb.grantPermissions(adbId, config.bundleId);
     }
     return {
-        startApp: async (options) => {
-            await adb.startApp(adbId, config.bundleId, config.activityName, options ??
-                config.appLaunchOptions);
-        },
-        restartApp: async (options) => {
-            await adb.stopApp(adbId, config.bundleId);
-            await adb.startApp(adbId, config.bundleId, config.activityName, options ??
-                config.appLaunchOptions);
-        },
-        stopApp: async () => {
+        createAppSession: async (options) => {
             await adb.stopApp(adbId, config.bundleId);
+            const launchOptions = options ??
+                config.appLaunchOptions;
+            return await createAndroidAppSession({
+                appUid,
+                bundleId: config.bundleId,
+                startApp: () => adb.startApp(adbId, config.bundleId, config.activityName, launchOptions),
+                stopApp: () => adb.stopApp(adbId, config.bundleId),
+                getAppPid: () => adb.getAppPid(adbId, config.bundleId),
+                getLogcatTimestamp: () => adb.getLogcatTimestamp(adbId),
+                startLogcat: (args, options) => adb.startLogcat(adbId, args, options),
+                getDropboxOutput: () => adb.getDropboxPrint(adbId),
+                getExitInfo: () => adb.getActivityExitInfo(adbId, config.bundleId),
+                crashArtifactWriter: init.crashArtifactWriter,
+                signal: init.signal,
+            });
         },
         dispose: async () => {
             await adb.stopApp(adbId, config.bundleId);
@@ -187,25 +188,11 @@ export const getAndroidEmulatorPlatformInstance = async (config, harnessConfig,
                 await adb.stopEmulator(adbId);
             }
         },
-        isAppRunning: async () => {
-            return await adb.isAppRunning(adbId, config.bundleId);
-        },
-        createAppMonitor: (options) => {
-            if (!detectNativeCrashes) {
-                return createNoopAppMonitor();
-            }
-            return createAndroidAppMonitor({
-                adbId,
-                bundleId: config.bundleId,
-                appUid,
-                crashArtifactWriter: options?.crashArtifactWriter,
-            });
-        },
     };
 };
-export const getAndroidPhysicalDevicePlatformInstance = async (config, harnessConfig) => {
+export const getAndroidPhysicalDevicePlatformInstance = async (config, harnessConfig, init) => {
     assertAndroidDevicePhysical(config.device);
-    const detectNativeCrashes = harnessConfig.detectNativeCrashes ?? true;
+    const adb = instrumented(adbModule, 'platform.android.adb', init?.diagnostics ?? noopDiagnostics);
     const permissionsEnabled = harnessConfig.permissions ?? false;
     const adbId = await getAdbId(config.device);
     if (!adbId) {
@@ -220,36 +207,28 @@ export const getAndroidPhysicalDevicePlatformInstance = async (config, harnessCo
         await adb.grantPermissions(adbId, config.bundleId);
     }
     return {
-        startApp: async (options) => {
-            await adb.startApp(adbId, config.bundleId, config.activityName, options ??
-                config.appLaunchOptions);
-        },
-        restartApp: async (options) => {
-            await adb.stopApp(adbId, config.bundleId);
-            await adb.startApp(adbId, config.bundleId, config.activityName, options ??
-                config.appLaunchOptions);
-        },
-        stopApp: async () => {
+        createAppSession: async (options) => {
             await adb.stopApp(adbId, config.bundleId);
+            const launchOptions = options ??
+                config.appLaunchOptions;
+            return await createAndroidAppSession({
+                appUid,
+                bundleId: config.bundleId,
+                startApp: () => adb.startApp(adbId, config.bundleId, config.activityName, launchOptions),
+                stopApp: () => adb.stopApp(adbId, config.bundleId),
+                getAppPid: () => adb.getAppPid(adbId, config.bundleId),
+                getLogcatTimestamp: () => adb.getLogcatTimestamp(adbId),
+                startLogcat: (args, options) => adb.startLogcat(adbId, args, options),
+                getDropboxOutput: () => adb.getDropboxPrint(adbId),
+                getExitInfo: () => adb.getActivityExitInfo(adbId, config.bundleId),
+                crashArtifactWriter: init?.crashArtifactWriter,
+                signal: init?.signal,
+            });
         },
         dispose: async () => {
             await adb.stopApp(adbId, config.bundleId);
             await clearHarnessDebugHttpHost(adbId, config.bundleId);
             await adb.setHideErrorDialogs(adbId, false);
         },
-        isAppRunning: async () => {
-            return await adb.isAppRunning(adbId, config.bundleId);
-        },
-        createAppMonitor: (options) => {
-            if (!detectNativeCrashes) {
-                return createNoopAppMonitor();
-            }
-            return createAndroidAppMonitor({
-                adbId,
-                bundleId: config.bundleId,
-                appUid,
-                crashArtifactWriter: options?.crashArtifactWriter,
-            });
-        },
     };
 };

package/dist/runner.d.ts

@@ -1,6 +1,6 @@
-import { HarnessPlatformRunner, type HarnessPlatformInitOptions } from '@react-native-harness/platforms';
+import { type HarnessPlatformRunnerFactory } from '@react-native-harness/platforms';
 import type { Config as HarnessConfig } from '@react-native-harness/config';
 import { type AndroidPlatformConfig } from './config.js';
-declare const getAndroidRunner: (config: AndroidPlatformConfig, harnessConfig: HarnessConfig, init: HarnessPlatformInitOptions) => Promise<HarnessPlatformRunner>;
+declare const getAndroidRunner: HarnessPlatformRunnerFactory<AndroidPlatformConfig, HarnessConfig>;
 export default getAndroidRunner;
 //# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,KAAK,0BAA0B,EAChC,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,EAEL,KAAK,qBAAqB,EAE3B,MAAM,aAAa,CAAC;AAUrB,QAAA,MAAM,gBAAgB,GACpB,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,EAC5B,MAAM,0BAA0B,KAC/B,OAAO,CAAC,qBAAqB,CAgB/B,CAAC;AAEF,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,4BAA4B,EAAE,MAAM,iCAAiC,CAAC;AACpF,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,EAEL,KAAK,qBAAqB,EAE3B,MAAM,aAAa,CAAC;AAUrB,QAAA,MAAM,gBAAgB,EAAE,4BAA4B,CAClD,qBAAqB,EACrB,aAAa,CAqBd,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/runner.js

@@ -8,6 +8,6 @@ const getAndroidRunner = async (config, harnessConfig, init) => {
     if (isAndroidDeviceEmulator(parsedConfig.device)) {
         return getAndroidEmulatorPlatformInstance(parsedConfig, harnessConfig, init);
     }
-    return getAndroidPhysicalDevicePlatformInstance(parsedConfig, harnessConfig);
+    return getAndroidPhysicalDevicePlatformInstance(parsedConfig, harnessConfig, init);
 };
 export default getAndroidRunner;