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

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,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,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

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

package/dist/instance.d.ts

@@ -0,0 +1,6 @@
+import { type HarnessPlatformInitOptions, HarnessPlatformRunner } from '@react-native-harness/platforms';
+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>;
+//# sourceMappingURL=instance.d.ts.map

package/dist/instance.d.ts.map

@@ -0,0 +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;AAgKrB,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,KAC3B,OAAO,CAAC,qBAAqB,CAiE/B,CAAC"}

package/dist/instance.js

@@ -0,0 +1,234 @@
+import { AppNotInstalledError, DeviceNotFoundError, } from '@react-native-harness/platforms';
+import { logger } 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 { applyHarnessDebugHttpHost, clearHarnessDebugHttpHost, } from './shared-prefs.js';
+import { getDeviceName } from './utils.js';
+import { createAndroidAppMonitor } from './app-monitor.js';
+import { HarnessAppPathError, HarnessEmulatorConfigError } from './errors.js';
+import { ensureAndroidEmulatorEnvironment, getHostAndroidSystemImageArch, } from './environment.js';
+import { isInteractive } from '@react-native-harness/tools';
+import fs from 'node:fs';
+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) {
+        throw new HarnessAppPathError('missing');
+    }
+    if (!fs.existsSync(appPath)) {
+        throw new HarnessAppPathError('invalid', appPath);
+    }
+    return appPath;
+};
+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),
+        applyHarnessDebugHttpHost(adbId, config.bundleId, `localhost:${metroPort}`),
+    ]);
+    return adb.getAppUid(adbId, config.bundleId);
+};
+const startAndWaitForBoot = async ({ emulatorName, signal, mode, }) => {
+    await adb.startEmulator(emulatorName, mode);
+    return adb.waitForBoot(emulatorName, signal);
+};
+const recreateAvd = async ({ emulatorConfig, }) => {
+    if (!emulatorConfig.avd) {
+        throw new HarnessEmulatorConfigError(emulatorConfig.name);
+    }
+    await adb.createAvd({
+        name: emulatorConfig.name,
+        apiLevel: emulatorConfig.avd.apiLevel,
+        profile: emulatorConfig.avd.profile,
+        diskSize: emulatorConfig.avd.diskSize,
+        heapSize: emulatorConfig.avd.heapSize,
+    });
+};
+const prepareCachedAvd = async ({ emulatorConfig, signal, }) => {
+    const emulatorName = emulatorConfig.name;
+    const hostArch = getHostAndroidSystemImageArch();
+    const hasExistingAvd = await adb.hasAvd(emulatorName);
+    const avdConfig = hasExistingAvd ? await readAvdConfig(emulatorName) : null;
+    const compatibility = avdConfig == null
+        ? { compatible: false, reason: 'Missing AVD config.ini.' }
+        : isAvdCompatible({
+            emulator: emulatorConfig,
+            avdConfig,
+            hostArch,
+        });
+    if (!hasExistingAvd || !compatibility.compatible) {
+        logger.info(hasExistingAvd
+            ? 'Recreating incompatible Android emulator %s...'
+            : '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 recreateAvd({ emulatorConfig });
+        const generationAdbId = await startAndWaitForBoot({
+            emulatorName,
+            signal,
+            mode: 'clean-snapshot-generation',
+        });
+        logger.info('Saving Android emulator snapshot for %s...', emulatorName);
+        await adb.stopEmulator(generationAdbId);
+        await adb.waitForEmulatorDisconnect(generationAdbId, signal);
+    }
+    else {
+        logger.info('Using cached Android emulator %s...', emulatorName);
+    }
+    return startAndWaitForBoot({
+        emulatorName,
+        signal,
+        mode: 'snapshot-reuse',
+    });
+};
+export const getAndroidEmulatorPlatformInstance = async (config, harnessConfig, init) => {
+    assertAndroidDeviceEmulator(config.device);
+    const detectNativeCrashes = harnessConfig.detectNativeCrashes ?? true;
+    const emulatorConfig = config.device;
+    const emulatorName = emulatorConfig.name;
+    const avdConfig = emulatorConfig.avd;
+    const avdCachingEnabled = resolveAvdCachingEnabled({
+        avd: avdConfig,
+        isInteractive: isInteractive(),
+    });
+    let adbId = await getAdbId(emulatorConfig);
+    let startedByHarness = false;
+    androidInstanceLogger.debug('resolved Android emulator %s with adb id %s', emulatorConfig.name, adbId ?? 'not-found');
+    if (!adbId) {
+        if (!avdConfig) {
+            throw new HarnessEmulatorConfigError(emulatorConfig.name);
+        }
+        await ensureAndroidEmulatorEnvironment(avdConfig.apiLevel);
+        adbId = avdCachingEnabled
+            ? await prepareCachedAvd({
+                emulatorConfig,
+                signal: init.signal,
+            })
+            : await (async () => {
+                if (!(await adb.hasAvd(emulatorConfig.name))) {
+                    logger.info('Creating Android emulator %s...', emulatorName);
+                    androidInstanceLogger.debug('creating Android AVD %s before startup', emulatorConfig.name);
+                    await recreateAvd({ emulatorConfig });
+                }
+                else {
+                    logger.info('Using existing Android emulator %s...', emulatorName);
+                }
+                androidInstanceLogger.debug('starting Android emulator %s', emulatorConfig.name);
+                return startAndWaitForBoot({
+                    emulatorName: emulatorConfig.name,
+                    signal: init.signal,
+                });
+            })();
+        startedByHarness = true;
+        androidInstanceLogger.debug('Android emulator %s connected as %s', emulatorConfig.name, adbId);
+    }
+    else if (emulatorConfig.avd) {
+        await ensureAndroidEmulatorEnvironment(emulatorConfig.avd.apiLevel);
+    }
+    if (!adbId) {
+        throw new DeviceNotFoundError(getDeviceName(emulatorConfig));
+    }
+    androidInstanceLogger.debug('waiting for Android emulator %s to finish booting', adbId);
+    const isInstalled = await adb.isAppInstalled(adbId, config.bundleId);
+    if (!isInstalled) {
+        const appPath = getHarnessAppPath();
+        await adb.installApp(adbId, appPath);
+    }
+    const appUid = await configureAndroidRuntime(adbId, config, harnessConfig);
+    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 () => {
+            await adb.stopApp(adbId, config.bundleId);
+        },
+        dispose: async () => {
+            await adb.stopApp(adbId, config.bundleId);
+            await clearHarnessDebugHttpHost(adbId, config.bundleId);
+            await adb.setHideErrorDialogs(adbId, false);
+            if (startedByHarness) {
+                logger.info('Shutting down Android emulator %s...', emulatorName);
+                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) => {
+    assertAndroidDevicePhysical(config.device);
+    const detectNativeCrashes = harnessConfig.detectNativeCrashes ?? true;
+    const adbId = await getAdbId(config.device);
+    if (!adbId) {
+        throw new DeviceNotFoundError(getDeviceName(config.device));
+    }
+    const isInstalled = await adb.isAppInstalled(adbId, config.bundleId);
+    if (!isInstalled) {
+        throw new AppNotInstalledError(config.bundleId, getDeviceName(config.device));
+    }
+    const appUid = await configureAndroidRuntime(adbId, config, harnessConfig);
+    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 () => {
+            await adb.stopApp(adbId, config.bundleId);
+        },
+        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 } from '@react-native-harness/platforms';
-import { Config } from '@react-native-harness/config';
+import { HarnessPlatformRunner, type HarnessPlatformInitOptions } 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: Config) => Promise<HarnessPlatformRunner>;
+declare const getAndroidRunner: (config: AndroidPlatformConfig, harnessConfig: HarnessConfig, init: HarnessPlatformInitOptions) => Promise<HarnessPlatformRunner>;
 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,EAIL,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AACtD,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAC;AAMrB,QAAA,MAAM,gBAAgB,GACpB,QAAQ,qBAAqB,EAC7B,eAAe,MAAM,KACpB,OAAO,CAAC,qBAAqB,CA+D/B,CAAC;AAEF,eAAe,gBAAgB,CAAC"}
+{"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;AAWrB,QAAA,MAAM,gBAAgB,GACpB,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,EAC5B,MAAM,0BAA0B,KAC/B,OAAO,CAAC,qBAAqB,CAoB/B,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/runner.js

@@ -1,52 +1,16 @@
-import { DeviceNotFoundError, AppNotInstalledError, } from '@react-native-harness/platforms';
-import { AndroidPlatformConfigSchema, } from './config.js';
-import { getAdbId } from './adb-id.js';
-import * as adb from './adb.js';
-import { getDeviceName } from './utils.js';
-import { createAndroidAppMonitor } from './app-monitor.js';
-const getAndroidRunner = async (config, harnessConfig) => {
+import { AndroidPlatformConfigSchema, isAndroidDeviceEmulator, } from './config.js';
+import { getAndroidEmulatorPlatformInstance, getAndroidPhysicalDevicePlatformInstance, } from './instance.js';
+import { ensureAndroidEmulatorEnvironment, ensureAndroidPhysicalDeviceEnvironment, initializeAndroidProcessEnv, } from './environment.js';
+const getAndroidRunner = async (config, harnessConfig, init) => {
     const parsedConfig = AndroidPlatformConfigSchema.parse(config);
-    const adbId = await getAdbId(parsedConfig.device);
-    if (!adbId) {
-        throw new DeviceNotFoundError(getDeviceName(parsedConfig.device));
+    initializeAndroidProcessEnv();
+    if (isAndroidDeviceEmulator(parsedConfig.device)) {
+        if (parsedConfig.device.avd) {
+            await ensureAndroidEmulatorEnvironment(parsedConfig.device.avd.apiLevel);
+        }
+        return getAndroidEmulatorPlatformInstance(parsedConfig, harnessConfig, init);
     }
-    const isInstalled = await adb.isAppInstalled(adbId, parsedConfig.bundleId);
-    if (!isInstalled) {
-        throw new AppNotInstalledError(parsedConfig.bundleId, getDeviceName(parsedConfig.device));
-    }
-    await Promise.all([
-        adb.reversePort(adbId, 8081),
-        adb.reversePort(adbId, 8080),
-        adb.reversePort(adbId, harnessConfig.webSocketPort),
-        adb.setHideErrorDialogs(adbId, true),
-    ]);
-    const appUid = await adb.getAppUid(adbId, parsedConfig.bundleId);
-    return {
-        startApp: async (options) => {
-            await adb.startApp(adbId, parsedConfig.bundleId, parsedConfig.activityName, options ??
-                parsedConfig.appLaunchOptions);
-        },
-        restartApp: async (options) => {
-            await adb.stopApp(adbId, parsedConfig.bundleId);
-            await adb.startApp(adbId, parsedConfig.bundleId, parsedConfig.activityName, options ??
-                parsedConfig.appLaunchOptions);
-        },
-        stopApp: async () => {
-            await adb.stopApp(adbId, parsedConfig.bundleId);
-        },
-        dispose: async () => {
-            await adb.stopApp(adbId, parsedConfig.bundleId);
-            await adb.setHideErrorDialogs(adbId, false);
-        },
-        isAppRunning: async () => {
-            return await adb.isAppRunning(adbId, parsedConfig.bundleId);
-        },
-        createAppMonitor: (options) => createAndroidAppMonitor({
-            adbId,
-            bundleId: parsedConfig.bundleId,
-            appUid,
-            crashArtifactWriter: options?.crashArtifactWriter,
-        }),
-    };
+    await ensureAndroidPhysicalDeviceEnvironment();
+    return getAndroidPhysicalDevicePlatformInstance(parsedConfig, harnessConfig);
 };
 export default getAndroidRunner;

package/dist/shared-prefs.d.ts

@@ -0,0 +1,3 @@
+export declare const applyHarnessDebugHttpHost: (adbId: string, bundleId: string, host: string) => Promise<void>;
+export declare const clearHarnessDebugHttpHost: (adbId: string, bundleId: string) => Promise<void>;
+//# sourceMappingURL=shared-prefs.d.ts.map

package/dist/shared-prefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-prefs.d.ts","sourceRoot":"","sources":["../src/shared-prefs.ts"],"names":[],"mappings":"AAsJA,eAAO,MAAM,yBAAyB,GACpC,OAAO,MAAM,EACb,UAAU,MAAM,EAChB,MAAM,MAAM,KACX,OAAO,CAAC,IAAI,CAoBd,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,OAAO,MAAM,EACb,UAAU,MAAM,KACf,OAAO,CAAC,IAAI,CAyBd,CAAC"}

package/dist/shared-prefs.js

@@ -0,0 +1,92 @@
+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) => `shared_prefs/${bundleId}_preferences.xml`;
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const escapeXml = (value) => value
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+const unescapeXml = (value) => value
+    .replaceAll('&apos;', "'")
+    .replaceAll('&quot;', '"')
+    .replaceAll('&gt;', '>')
+    .replaceAll('&lt;', '<')
+    .replaceAll('&amp;', '&');
+const getStringPreferenceRegex = (key) => new RegExp(`<string\\s+name="${escapeRegExp(key)}">([\\s\\S]*?)<\\/string>`, 'g');
+const getStringPreferenceValue = (content, key) => {
+    const matches = [...content.matchAll(getStringPreferenceRegex(key))];
+    const value = matches.at(-1)?.[1];
+    return value == null ? null : unescapeXml(value);
+};
+const renameStringPreference = (content, fromKey, toKey) => content.replace(new RegExp(`(<string\\s+name=")${escapeRegExp(fromKey)}(">[\\s\\S]*?<\\/string>)`, 'g'), `$1${toKey}$2`);
+const stripStringPreference = (content, key) => content.replace(new RegExp(`\\s*<string\\s+name="${escapeRegExp(key)}">[\\s\\S]*?<\\/string>\\s*`, 'g'), '\n');
+const normalizeEmptyMap = (content) => content.replace(/<map\s*\/>/g, '<map>\n</map>');
+const getHarnessDebugHttpHostBlock = (host) => [
+    DEBUG_HTTP_HOST_BLOCK_START,
+    `<string name="debug_http_host">${escapeXml(host)}</string>`,
+    DEBUG_HTTP_HOST_BLOCK_END,
+].join('\n');
+const stripHarnessDebugHttpHostBlock = (content) => 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) => {
+    if (!content?.trim()) {
+        return ['<?xml version="1.0" encoding="utf-8"?>', '<map>', '</map>'].join('\n');
+    }
+    return normalizeEmptyMap(stripHarnessDebugHttpHostBlock(content)).trim();
+};
+const insertBeforeClosingMap = (content, block) => {
+    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, bundleId) => {
+    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, bundleId, content) => {
+    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, bundleId, host) => {
+    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, bundleId) => {
+    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/dist/targets.d.ts

@@ -1,3 +1,3 @@
-import { RunTarget } from "@react-native-harness/platforms";
+import { RunTarget } from '@react-native-harness/platforms';
 export declare const getRunTargets: () => Promise<RunTarget[]>;
 //# sourceMappingURL=targets.d.ts.map

package/dist/targets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../src/targets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAG5D,eAAO,MAAM,aAAa,QAAa,OAAO,CAAC,SAAS,EAAE,CAkCzD,CAAC"}
+{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../src/targets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAI5D,eAAO,MAAM,aAAa,QAAa,OAAO,CAAC,SAAS,EAAE,CAoCzD,CAAC"}

package/dist/targets.js

@@ -1,5 +1,7 @@
 import * as adb from './adb.js';
+import { ensureAndroidDiscoveryEnvironment } from './environment.js';
 export const getRunTargets = async () => {
+    await ensureAndroidDiscoveryEnvironment();
     const [avds, connectedDevices] = await Promise.all([
         adb.getAvds(),
         adb.getConnectedDevices(),