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

package/src/runner.ts

@@ -1,20 +1,26 @@
 import {
   DeviceNotFoundError,
   AppNotInstalledError,
+  CreateAppMonitorOptions,
   HarnessPlatformRunner,
 } from '@react-native-harness/platforms';
-import { Config } from '@react-native-harness/config';
+import type { Config as HarnessConfig } from '@react-native-harness/config';
 import {
   AndroidPlatformConfigSchema,
   type AndroidPlatformConfig,
 } from './config.js';
 import { getAdbId } from './adb-id.js';
 import * as adb from './adb.js';
+import {
+  applyHarnessDebugHttpHost,
+  clearHarnessDebugHttpHost,
+} from './shared-prefs.js';
 import { getDeviceName } from './utils.js';
+import { createAndroidAppMonitor } from './app-monitor.js';
 
 const getAndroidRunner = async (
   config: AndroidPlatformConfig,
-  harnessConfig: Config
+  harnessConfig: HarnessConfig
 ): Promise<HarnessPlatformRunner> => {
   const parsedConfig = AndroidPlatformConfigSchema.parse(config);
   const adbId = await getAdbId(parsedConfig.device);
@@ -32,26 +38,35 @@ const getAndroidRunner = async (
     );
   }
 
+  const metroPort = harnessConfig.metroPort;
+
   await Promise.all([
-    adb.reversePort(adbId, 8081),
+    adb.reversePort(adbId, metroPort),
     adb.reversePort(adbId, 8080),
     adb.reversePort(adbId, harnessConfig.webSocketPort),
+    adb.setHideErrorDialogs(adbId, true),
+    applyHarnessDebugHttpHost(adbId, parsedConfig.bundleId, `localhost:${metroPort}`),
   ]);
+  const appUid = await adb.getAppUid(adbId, parsedConfig.bundleId);
 
   return {
-    startApp: async () => {
+    startApp: async (options) => {
       await adb.startApp(
         adbId,
         parsedConfig.bundleId,
-        parsedConfig.activityName
+        parsedConfig.activityName,
+        (options as typeof parsedConfig.appLaunchOptions | undefined) ??
+          parsedConfig.appLaunchOptions
       );
     },
-    restartApp: async () => {
+    restartApp: async (options) => {
       await adb.stopApp(adbId, parsedConfig.bundleId);
       await adb.startApp(
         adbId,
         parsedConfig.bundleId,
-        parsedConfig.activityName
+        parsedConfig.activityName,
+        (options as typeof parsedConfig.appLaunchOptions | undefined) ??
+          parsedConfig.appLaunchOptions
       );
     },
     stopApp: async () => {
@@ -59,10 +74,19 @@ const getAndroidRunner = async (
     },
     dispose: async () => {
       await adb.stopApp(adbId, parsedConfig.bundleId);
+      await clearHarnessDebugHttpHost(adbId, parsedConfig.bundleId);
+      await adb.setHideErrorDialogs(adbId, false);
     },
     isAppRunning: async () => {
       return await adb.isAppRunning(adbId, parsedConfig.bundleId);
     },
+    createAppMonitor: (options?: CreateAppMonitorOptions) =>
+      createAndroidAppMonitor({
+        adbId,
+        bundleId: parsedConfig.bundleId,
+        appUid,
+        crashArtifactWriter: options?.crashArtifactWriter,
+      }),
   };
 };
 

package/src/shared-prefs.ts

@@ -0,0 +1,205 @@
+import { spawn, SubprocessError } from '@react-native-harness/tools';
+
+const DEBUG_HTTP_HOST_BLOCK_START =
+  '<!-- react-native-harness:debug_http_host:start -->';
+const DEBUG_HTTP_HOST_BLOCK_END =
+  '<!-- react-native-harness:debug_http_host:end -->';
+const DEBUG_HTTP_HOST_BACKUP_KEY = 'harness_debug_http_host_backup';
+
+const getSharedPrefsPath = (bundleId: string) =>
+  `shared_prefs/${bundleId}_preferences.xml`;
+
+const escapeRegExp = (value: string): string =>
+  value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+const escapeXml = (value: string): string =>
+  value
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+
+const unescapeXml = (value: string): string =>
+  value
+    .replaceAll('&apos;', "'")
+    .replaceAll('&quot;', '"')
+    .replaceAll('&gt;', '>')
+    .replaceAll('&lt;', '<')
+    .replaceAll('&amp;', '&');
+
+const getStringPreferenceRegex = (key: string) =>
+  new RegExp(
+    `<string\\s+name="${escapeRegExp(key)}">([\\s\\S]*?)<\\/string>`,
+    'g'
+  );
+
+const getStringPreferenceValue = (
+  content: string,
+  key: string
+): string | null => {
+  const matches = [...content.matchAll(getStringPreferenceRegex(key))];
+  const value = matches.at(-1)?.[1];
+
+  return value == null ? null : unescapeXml(value);
+};
+
+const renameStringPreference = (
+  content: string,
+  fromKey: string,
+  toKey: string
+): string =>
+  content.replace(
+    new RegExp(
+      `(<string\\s+name=")${escapeRegExp(fromKey)}(">[\\s\\S]*?<\\/string>)`,
+      'g'
+    ),
+    `$1${toKey}$2`
+  );
+
+const stripStringPreference = (content: string, key: string): string =>
+  content.replace(
+    new RegExp(
+      `\\s*<string\\s+name="${escapeRegExp(key)}">[\\s\\S]*?<\\/string>\\s*`,
+      'g'
+    ),
+    '\n'
+  );
+
+const normalizeEmptyMap = (content: string): string =>
+  content.replace(/<map\s*\/>/g, '<map>\n</map>');
+
+const getHarnessDebugHttpHostBlock = (host: string) =>
+  [
+    DEBUG_HTTP_HOST_BLOCK_START,
+    `<string name="debug_http_host">${escapeXml(host)}</string>`,
+    DEBUG_HTTP_HOST_BLOCK_END,
+  ].join('\n');
+
+const stripHarnessDebugHttpHostBlock = (content: string): string =>
+  content.replace(
+    new RegExp(
+      `\\s*${escapeRegExp(
+        DEBUG_HTTP_HOST_BLOCK_START
+      )}\\s*\\n[\\s\\S]*?\\n\\s*${escapeRegExp(DEBUG_HTTP_HOST_BLOCK_END)}\\s*`,
+      'g'
+    ),
+    '\n'
+  );
+
+const normalizeSharedPrefsContent = (content: string | null): string => {
+  if (!content?.trim()) {
+    return ['<?xml version="1.0" encoding="utf-8"?>', '<map>', '</map>'].join(
+      '\n'
+    );
+  }
+
+  return normalizeEmptyMap(stripHarnessDebugHttpHostBlock(content)).trim();
+};
+
+const insertBeforeClosingMap = (content: string, block: string): string => {
+  if (!content.includes('</map>')) {
+    throw new Error('Android shared preferences file is missing </map>.');
+  }
+
+  return content.replace(
+    /<\/map>\s*$/,
+    `  ${block.replace(/\n/g, '\n  ')}\n</map>`
+  );
+};
+
+const readSharedPrefsFile = async (
+  adbId: string,
+  bundleId: string
+): Promise<string | null> => {
+  try {
+    const { stdout } = await spawn('adb', [
+      '-s',
+      adbId,
+      'shell',
+      `run-as ${bundleId} cat ${getSharedPrefsPath(bundleId)}`,
+    ]);
+    return stdout;
+  } catch (error) {
+    if (error instanceof SubprocessError && error.exitCode === 1) {
+      return null;
+    }
+
+    throw error;
+  }
+};
+
+const writeSharedPrefsFile = async (
+  adbId: string,
+  bundleId: string,
+  content: string
+): Promise<void> => {
+  await spawn(
+    'adb',
+    [
+      '-s',
+      adbId,
+      'shell',
+      `run-as ${bundleId} sh -c 'mkdir -p shared_prefs && cat > ${getSharedPrefsPath(
+        bundleId
+      )}'`,
+    ],
+    { stdin: { string: `${content.trim()}\n` } }
+  );
+};
+
+export const applyHarnessDebugHttpHost = async (
+  adbId: string,
+  bundleId: string,
+  host: string
+): Promise<void> => {
+  const existingContent = await readSharedPrefsFile(adbId, bundleId);
+  const normalizedContent = normalizeSharedPrefsContent(existingContent);
+  const existingHost = getStringPreferenceValue(
+    normalizedContent,
+    'debug_http_host'
+  );
+  const contentWithBackup =
+    existingHost == null
+      ? normalizedContent
+      : renameStringPreference(
+          stripStringPreference(normalizedContent, DEBUG_HTTP_HOST_BACKUP_KEY),
+          'debug_http_host',
+          DEBUG_HTTP_HOST_BACKUP_KEY
+        );
+  const nextContent = insertBeforeClosingMap(
+    contentWithBackup,
+    getHarnessDebugHttpHostBlock(host)
+  );
+  await writeSharedPrefsFile(adbId, bundleId, nextContent);
+};
+
+export const clearHarnessDebugHttpHost = async (
+  adbId: string,
+  bundleId: string
+): Promise<void> => {
+  const existingContent = await readSharedPrefsFile(adbId, bundleId);
+
+  if (!existingContent) {
+    return;
+  }
+
+  const nextContentWithoutHarnessBlock =
+    stripHarnessDebugHttpHostBlock(existingContent).trim();
+
+  if (nextContentWithoutHarnessBlock === existingContent.trim()) {
+    return;
+  }
+
+  const restoredContent = renameStringPreference(
+    nextContentWithoutHarnessBlock,
+    DEBUG_HTTP_HOST_BACKUP_KEY,
+    'debug_http_host'
+  );
+
+  await writeSharedPrefsFile(
+    adbId,
+    bundleId,
+    normalizeEmptyMap(restoredContent).trim()
+  );
+};

package/tsconfig.json

@@ -4,10 +4,10 @@
   "include": [],
   "references": [
     {
-      "path": "../config"
+      "path": "../tools"
     },
     {
-      "path": "../tools"
+      "path": "../config"
     },
     {
       "path": "../platforms"

package/tsconfig.lib.json

@@ -12,10 +12,10 @@
   "include": ["src/**/*.ts"],
   "references": [
     {
-      "path": "../config/tsconfig.lib.json"
+      "path": "../tools/tsconfig.lib.json"
     },
     {
-      "path": "../tools/tsconfig.lib.json"
+      "path": "../config/tsconfig.lib.json"
     },
     {
       "path": "../platforms/tsconfig.lib.json"

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"fileNames":[],"fileInfos":[],"root":[],"options":{"composite":true,"declarationMap":true,"emitDeclarationOnly":true,"importHelpers":true,"module":199,"noEmitOnError":true,"noFallthroughCasesInSwitch":true,"noImplicitOverride":true,"noImplicitReturns":true,"noUnusedLocals":true,"skipLibCheck":true,"strict":true,"target":9},"version":"5.9.3"}

package/dist/assertions.d.ts

@@ -1,5 +0,0 @@
-import { Config, NativeTestRunnerConfig } from './types.js';
-export declare function assertNativeRunner(config: Config): asserts config is Config & {
-    runner: NativeTestRunnerConfig;
-};
-//# sourceMappingURL=assertions.d.ts.map

package/dist/assertions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../src/assertions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAE5D,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,IAAI,MAAM,GAAG;IAAE,MAAM,EAAE,sBAAsB,CAAA;CAAE,CAO/D"}

package/dist/assertions.js

@@ -1,6 +0,0 @@
-export function assertNativeRunner(config) {
-    if (config.runner.platform !== 'ios' &&
-        config.runner.platform !== 'android') {
-        throw new Error('Runner is not a native runner');
-    }
-}

package/dist/emulator.d.ts

@@ -1,6 +0,0 @@
-export type AndroidEmulator = {
-    adbId: string;
-    stop: () => Promise<void>;
-};
-export declare const runEmulator: (avdName: string) => Promise<AndroidEmulator>;
-//# sourceMappingURL=emulator.d.ts.map

package/dist/emulator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"emulator.d.ts","sourceRoot":"","sources":["../src/emulator.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B,CAAC;AAEF,eAAO,MAAM,WAAW,GACtB,SAAS,MAAM,KACd,OAAO,CAAC,eAAe,CA8BzB,CAAC"}

package/dist/emulator.js

@@ -1,27 +0,0 @@
-import { spawn } from '@react-native-harness/tools';
-import * as adb from './adb.js';
-export const runEmulator = async (avdName) => {
-    const process = spawn('emulator', ['-avd', avdName]);
-    await process.nodeChildProcess;
-    const adbId = await adb.getEmulatorName(avdName);
-    if (!adbId) {
-        throw new Error('Emulator not found');
-    }
-    // Poll for emulator status until it's fully running
-    const checkStatus = async () => {
-        const status = await adb.isBootCompleted(adbId);
-        if (!status) {
-            await new Promise((resolve) => setTimeout(resolve, 2000));
-            await checkStatus();
-        }
-    };
-    // Start checking status after a brief delay to allow emulator to start
-    await new Promise((resolve) => setTimeout(resolve, 3000));
-    await checkStatus();
-    return {
-        adbId,
-        stop: async () => {
-            await adb.stopEmulator(adbId);
-        },
-    };
-};

package/dist/errors.d.ts

@@ -1,15 +0,0 @@
-export declare class ConfigValidationError extends Error {
-    readonly filePath: string;
-    readonly validationErrors: string[];
-    constructor(filePath: string, validationErrors: string[]);
-}
-export declare class ConfigNotFoundError extends Error {
-    readonly searchPath: string;
-    constructor(searchPath: string);
-}
-export declare class ConfigLoadError extends Error {
-    readonly filePath: string;
-    readonly cause?: Error;
-    constructor(filePath: string, cause?: Error);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,qBAAsB,SAAQ,KAAK;aAExB,QAAQ,EAAE,MAAM;aAChB,gBAAgB,EAAE,MAAM,EAAE;gBAD1B,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EAAE;CAKjD;AAED,qBAAa,mBAAoB,SAAQ,KAAK;aACd,UAAU,EAAE,MAAM;gBAAlB,UAAU,EAAE,MAAM;CAIjD;AAED,qBAAa,eAAgB,SAAQ,KAAK;aAGV,QAAQ,EAAE,MAAM;IAF5C,SAAyB,KAAK,CAAC,EAAE,KAAK,CAAC;gBAEX,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAK9D"}

package/dist/errors.js

@@ -1,28 +0,0 @@
-export class ConfigValidationError extends Error {
-    filePath;
-    validationErrors;
-    constructor(filePath, validationErrors) {
-        super(`Invalid configuration in ${filePath}`);
-        this.filePath = filePath;
-        this.validationErrors = validationErrors;
-        this.name = 'ConfigValidationError';
-    }
-}
-export class ConfigNotFoundError extends Error {
-    searchPath;
-    constructor(searchPath) {
-        super(`Config file not found in ${searchPath} or any parent directories`);
-        this.searchPath = searchPath;
-        this.name = 'ConfigNotFoundError';
-    }
-}
-export class ConfigLoadError extends Error {
-    filePath;
-    cause;
-    constructor(filePath, cause) {
-        super(`Failed to load config file ${filePath}`);
-        this.filePath = filePath;
-        this.name = 'ConfigLoadError';
-        this.cause = cause;
-    }
-}

package/dist/reader.d.ts

@@ -1,6 +0,0 @@
-import { Config } from './types.js';
-export declare const getConfig: (dir: string) => Promise<{
-    config: Config;
-    projectRoot: string;
-}>;
-//# sourceMappingURL=reader.d.ts.map

package/dist/reader.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../src/reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAgB,MAAM,YAAY,CAAC;AAsElD,eAAO,MAAM,SAAS,GACpB,KAAK,MAAM,KACV,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAUjD,CAAC"}

package/dist/reader.js

@@ -1,57 +0,0 @@
-import { ConfigSchema } from './types.js';
-import { ConfigValidationError, ConfigNotFoundError, ConfigLoadError, } from './errors.js';
-import path from 'node:path';
-import fs from 'node:fs';
-import { createRequire } from 'node:module';
-import { ZodError } from 'zod';
-const extensions = ['.js', '.mjs', '.cjs', '.json'];
-const importUp = async (dir, name) => {
-    const filePath = path.join(dir, name);
-    for (const ext of extensions) {
-        const filePathWithExt = `${filePath}${ext}`;
-        if (fs.existsSync(filePathWithExt)) {
-            let rawConfig;
-            try {
-                if (ext === '.mjs') {
-                    rawConfig = await import(filePathWithExt).then((module) => module.default);
-                }
-                else {
-                    const require = createRequire(import.meta.url);
-                    rawConfig = require(filePathWithExt);
-                }
-            }
-            catch (error) {
-                throw new ConfigLoadError(filePathWithExt, error instanceof Error ? error : undefined);
-            }
-            try {
-                const config = ConfigSchema.parse(rawConfig);
-                return { config, filePathWithExt, configDir: dir };
-            }
-            catch (error) {
-                if (error instanceof ZodError) {
-                    const validationErrors = error.errors.map((err) => {
-                        const path = err.path.length > 0 ? ` at "${err.path.join('.')}"` : '';
-                        return `${err.message}${path}`;
-                    });
-                    throw new ConfigValidationError(filePathWithExt, validationErrors);
-                }
-                throw error;
-            }
-        }
-    }
-    const parentDir = path.dirname(dir);
-    if (parentDir === dir) {
-        throw new ConfigNotFoundError(dir);
-    }
-    return importUp(parentDir, name);
-};
-export const getConfig = async (dir) => {
-    const { config, configDir } = await importUp(dir, 'rn-harness.config');
-    return {
-        config: {
-            ...config,
-            reporter: config.reporter,
-        },
-        projectRoot: configDir,
-    };
-};