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

package/dist/adb.js

@@ -1,4 +1,84 @@
 import { spawn, SubprocessError } from '@react-native-harness/tools';
+import { spawn as nodeSpawn } from 'node:child_process';
+import { access, rm } from 'node:fs/promises';
+import { ensureAndroidEmulatorAvailable, ensureAndroidSdkPackages, getAdbBinaryPath, getAndroidSystemImagePackage, getAvdManagerBinaryPath, getEmulatorBinaryPath, getHostAndroidSystemImageArch, getRequiredAndroidSdkPackages, } from './environment.js';
+import { getEmulatorStartupArgs, } from './emulator-startup.js';
+const wait = async (ms) => {
+    await new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+};
+const waitForAbort = (signal) => {
+    if (signal.aborted) {
+        return Promise.reject(signal.reason);
+    }
+    return new Promise((_, reject) => {
+        signal.addEventListener('abort', () => {
+            reject(signal.reason);
+        }, { once: true });
+    });
+};
+const waitWithSignal = async (ms, signal) => {
+    if (signal.aborted) {
+        throw signal.reason;
+    }
+    await Promise.race([wait(ms), waitForAbort(signal)]);
+};
+const getAvdConfigPath = (name) => `${process.env.ANDROID_AVD_HOME ?? `${process.env.HOME}/.android/avd`}/${name}.avd/config.ini`;
+const EMULATOR_STARTUP_OBSERVATION_TIMEOUT_MS = 5000;
+const EMULATOR_OUTPUT_BUFFER_LIMIT = 16 * 1024;
+export const emulatorProcess = {
+    startDetachedProcess: (file, args) => nodeSpawn(file, args, {
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    }),
+};
+const appendBoundedOutput = (output, chunk, limit = EMULATOR_OUTPUT_BUFFER_LIMIT) => {
+    const nextOutput = output + chunk;
+    if (nextOutput.length <= limit) {
+        return nextOutput;
+    }
+    return nextOutput.slice(-limit);
+};
+const formatEmulatorStartupError = ({ name, stdout, stderr, exitCode, signal, error, }) => {
+    const sections = [`Failed to start Android emulator @${name}.`];
+    if (typeof exitCode === 'number') {
+        sections.push(`Exit code: ${exitCode}`);
+    }
+    if (signal) {
+        sections.push(`Signal: ${signal}`);
+    }
+    if (error instanceof Error) {
+        sections.push(`Cause: ${error.message}`);
+    }
+    const trimmedStdout = stdout.trim();
+    const trimmedStderr = stderr.trim();
+    if (trimmedStdout !== '') {
+        sections.push(`stdout:\n${trimmedStdout}`);
+    }
+    if (trimmedStderr !== '') {
+        sections.push(`stderr:\n${trimmedStderr}`);
+    }
+    return new Error(sections.join('\n\n'), {
+        cause: error instanceof Error ? error : undefined,
+    });
+};
+const ensureEmulatorInstalled = async () => {
+    await ensureAndroidEmulatorAvailable();
+    const emulatorBinaryPath = getEmulatorBinaryPath();
+    await access(emulatorBinaryPath);
+    return emulatorBinaryPath;
+};
+export const getRequiredEmulatorPackages = (apiLevel) => {
+    return getRequiredAndroidSdkPackages({
+        apiLevel,
+        includeEmulator: true,
+        architecture: getHostAndroidSystemImageArch(),
+    });
+};
+export const verifyAndroidEmulatorSdk = async (apiLevel) => {
+    await ensureAndroidSdkPackages(getRequiredEmulatorPackages(apiLevel));
+};
 export const getStartAppArgs = (bundleId, activityName, options) => {
     const args = [
         'shell',
@@ -29,7 +109,7 @@ export const getStartAppArgs = (bundleId, activityName, options) => {
     return args;
 };
 export const isAppInstalled = async (adbId, bundleId) => {
-    const { stdout } = await spawn('adb', [
+    const { stdout } = await spawn(getAdbBinaryPath(), [
         '-s',
         adbId,
         'shell',
@@ -41,7 +121,7 @@ export const isAppInstalled = async (adbId, bundleId) => {
     return stdout.trim() !== '';
 };
 export const reversePort = async (adbId, port, hostPort = port) => {
-    await spawn('adb', [
+    await spawn(getAdbBinaryPath(), [
         '-s',
         adbId,
         'reverse',
@@ -50,13 +130,24 @@ export const reversePort = async (adbId, port, hostPort = port) => {
     ]);
 };
 export const stopApp = async (adbId, bundleId) => {
-    await spawn('adb', ['-s', adbId, 'shell', 'am', 'force-stop', bundleId]);
+    await spawn(getAdbBinaryPath(), [
+        '-s',
+        adbId,
+        'shell',
+        'am',
+        'force-stop',
+        bundleId,
+    ]);
 };
 export const startApp = async (adbId, bundleId, activityName, options) => {
-    await spawn('adb', ['-s', adbId, ...getStartAppArgs(bundleId, activityName, options)]);
+    await spawn(getAdbBinaryPath(), [
+        '-s',
+        adbId,
+        ...getStartAppArgs(bundleId, activityName, options),
+    ]);
 };
 export const getDeviceIds = async () => {
-    const { stdout } = await spawn('adb', ['devices']);
+    const { stdout } = await spawn(getAdbBinaryPath(), ['devices']);
     return stdout
         .split('\n')
         .slice(1) // Skip header
@@ -64,11 +155,17 @@ export const getDeviceIds = async () => {
         .map((line) => line.split('\t')[0]);
 };
 export const getEmulatorName = async (adbId) => {
-    const { stdout } = await spawn('adb', ['-s', adbId, 'emu', 'avd', 'name']);
+    const { stdout } = await spawn(getAdbBinaryPath(), [
+        '-s',
+        adbId,
+        'emu',
+        'avd',
+        'name',
+    ]);
     return stdout.split('\n')[0].trim() || null;
 };
 export const getShellProperty = async (adbId, property) => {
-    const { stdout } = await spawn('adb', [
+    const { stdout } = await spawn(getAdbBinaryPath(), [
         '-s',
         adbId,
         'shell',
@@ -77,21 +174,166 @@ export const getShellProperty = async (adbId, property) => {
     ]);
     return stdout.trim() || null;
 };
+const isTransientAdbShellFailure = (error) => {
+    return error instanceof SubprocessError && error.exitCode === 1;
+};
 export const getDeviceInfo = async (adbId) => {
     const manufacturer = await getShellProperty(adbId, 'ro.product.manufacturer');
     const model = await getShellProperty(adbId, 'ro.product.model');
     return { manufacturer, model };
 };
 export const isBootCompleted = async (adbId) => {
-    const bootCompleted = await getShellProperty(adbId, 'sys.boot_completed');
-    return bootCompleted === '1';
+    try {
+        const bootCompleted = await getShellProperty(adbId, 'sys.boot_completed');
+        return bootCompleted === '1';
+    }
+    catch (error) {
+        if (isTransientAdbShellFailure(error)) {
+            return false;
+        }
+        throw error;
+    }
 };
 export const stopEmulator = async (adbId) => {
-    await spawn('adb', ['-s', adbId, 'emu', 'kill']);
+    await spawn(getAdbBinaryPath(), ['-s', adbId, 'emu', 'kill']);
+};
+export const installApp = async (adbId, appPath) => {
+    await spawn(getAdbBinaryPath(), ['-s', adbId, 'install', '-r', appPath]);
+};
+export const hasAvd = async (name) => {
+    const avds = await getAvds();
+    return avds.includes(name);
+};
+export const createAvd = async ({ name, apiLevel, profile, diskSize, heapSize, }) => {
+    const systemImagePackage = getAndroidSystemImagePackage(apiLevel, getHostAndroidSystemImageArch());
+    await verifyAndroidEmulatorSdk(apiLevel);
+    await spawn('bash', [
+        '-lc',
+        `printf 'no\n' | "${getAvdManagerBinaryPath()}" create avd --force --name "${name}" --package "${systemImagePackage}" --device "${profile}"`,
+    ]);
+    await spawn('bash', [
+        '-lc',
+        `printf '%s\n%s\n' 'disk.dataPartition.size=${diskSize}' 'vm.heapSize=${heapSize}' >> "${getAvdConfigPath(name)}"`,
+    ]);
+};
+export const deleteAvd = async (name) => {
+    await rm(`${process.env.ANDROID_AVD_HOME ?? `${process.env.HOME}/.android/avd`}/${name}.avd`, {
+        force: true,
+        recursive: true,
+    });
+    await rm(`${process.env.ANDROID_AVD_HOME ?? `${process.env.HOME}/.android/avd`}/${name}.ini`, {
+        force: true,
+    });
+};
+export const startEmulator = async (name, mode = 'default-boot') => {
+    const emulatorBinaryPath = await ensureEmulatorInstalled();
+    const childProcess = emulatorProcess.startDetachedProcess(emulatorBinaryPath, getEmulatorStartupArgs(name, mode));
+    let stdout = '';
+    let stderr = '';
+    childProcess.stdout?.setEncoding('utf8');
+    childProcess.stderr?.setEncoding('utf8');
+    const onStdout = (chunk) => {
+        stdout = appendBoundedOutput(stdout, chunk.toString());
+    };
+    const onStderr = (chunk) => {
+        stderr = appendBoundedOutput(stderr, chunk.toString());
+    };
+    childProcess.stdout?.on('data', onStdout);
+    childProcess.stderr?.on('data', onStderr);
+    const startupAbortController = new AbortController();
+    const cleanup = () => {
+        startupAbortController.abort();
+        childProcess.stdout?.off('data', onStdout);
+        childProcess.stderr?.off('data', onStderr);
+        childProcess.removeAllListeners('error');
+        childProcess.removeAllListeners('close');
+    };
+    const earlyExit = new Promise((_, reject) => {
+        childProcess.once('error', (error) => {
+            reject(formatEmulatorStartupError({
+                name,
+                stdout,
+                stderr,
+                error,
+            }));
+        });
+        childProcess.once('close', (exitCode, signal) => {
+            reject(formatEmulatorStartupError({
+                name,
+                stdout,
+                stderr,
+                exitCode,
+                signal,
+            }));
+        });
+    });
+    const observedBoot = waitForEmulator(name, startupAbortController.signal)
+        .then(() => 'booted')
+        .catch((error) => {
+        if (startupAbortController.signal.aborted) {
+            return 'aborted';
+        }
+        throw error;
+    });
+    const observationTimeout = wait(EMULATOR_STARTUP_OBSERVATION_TIMEOUT_MS).then(() => 'timeout');
+    try {
+        await Promise.race([earlyExit, observedBoot, observationTimeout]);
+    }
+    finally {
+        cleanup();
+    }
+    childProcess.stdout?.destroy();
+    childProcess.stderr?.destroy();
+    childProcess.unref();
+};
+export const waitForEmulator = async (name, signal) => {
+    while (!signal.aborted) {
+        const adbIds = await getDeviceIds();
+        for (const adbId of adbIds) {
+            if (!adbId.startsWith('emulator-')) {
+                continue;
+            }
+            const emulatorName = await getEmulatorName(adbId);
+            if (emulatorName === name) {
+                return adbId;
+            }
+        }
+        await waitWithSignal(1000, signal);
+    }
+    throw signal.reason;
+};
+export const waitForEmulatorDisconnect = async (adbId, signal) => {
+    while (!signal.aborted) {
+        const adbIds = await getDeviceIds();
+        if (!adbIds.includes(adbId)) {
+            return;
+        }
+        await waitWithSignal(1000, signal);
+    }
+    throw signal.reason;
+};
+export const waitForBoot = async (name, signal) => {
+    while (!signal.aborted) {
+        const adbIds = await getDeviceIds();
+        for (const adbId of adbIds) {
+            if (!adbId.startsWith('emulator-')) {
+                continue;
+            }
+            const emulatorName = await getEmulatorName(adbId);
+            if (emulatorName !== name) {
+                continue;
+            }
+            if (await isBootCompleted(adbId)) {
+                return adbId;
+            }
+        }
+        await waitWithSignal(1000, signal);
+    }
+    throw signal.reason;
 };
 export const isAppRunning = async (adbId, bundleId) => {
     try {
-        const { stdout } = await spawn('adb', [
+        const { stdout } = await spawn(getAdbBinaryPath(), [
             '-s',
             adbId,
             'shell',
@@ -108,7 +350,7 @@ export const isAppRunning = async (adbId, bundleId) => {
     }
 };
 export const getAppUid = async (adbId, bundleId) => {
-    const { stdout } = await spawn('adb', [
+    const { stdout } = await spawn(getAdbBinaryPath(), [
         '-s',
         adbId,
         'shell',
@@ -127,7 +369,7 @@ export const getAppUid = async (adbId, bundleId) => {
     return Number(match[1]);
 };
 export const setHideErrorDialogs = async (adbId, hide) => {
-    await spawn('adb', [
+    await spawn(getAdbBinaryPath(), [
         '-s',
         adbId,
         'shell',
@@ -139,7 +381,7 @@ export const setHideErrorDialogs = async (adbId, hide) => {
     ]);
 };
 export const getLogcatTimestamp = async (adbId) => {
-    const { stdout } = await spawn('adb', [
+    const { stdout } = await spawn(getAdbBinaryPath(), [
         '-s',
         adbId,
         'shell',
@@ -150,7 +392,8 @@ export const getLogcatTimestamp = async (adbId) => {
 };
 export const getAvds = async () => {
     try {
-        const { stdout } = await spawn('emulator', ['-list-avds']);
+        const emulatorBinaryPath = await ensureEmulatorInstalled();
+        const { stdout } = await spawn(emulatorBinaryPath, ['-list-avds']);
         return stdout
             .split('\n')
             .map((line) => line.trim())
@@ -161,7 +404,7 @@ export const getAvds = async () => {
     }
 };
 export const getConnectedDevices = async () => {
-    const { stdout } = await spawn('adb', ['devices', '-l']);
+    const { stdout } = await spawn(getAdbBinaryPath(), ['devices', '-l']);
     const lines = stdout.split('\n').slice(1);
     const devices = [];
     for (const line of lines) {

package/dist/app-monitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"app-monitor.d.ts","sourceRoot":"","sources":["../src/app-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,eAAe,EAErB,MAAM,iCAAiC,CAAC;AAuRzC,QAAA,MAAM,qBAAqB,GACzB,MAAM,MAAM,EACZ,UAAU,MAAM,KACf,eAAe,GAAG,IAwEpB,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,mDAKrC;IACD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;CAC3C,KAAG,iBAmKH,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC;AACjC,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG;IAC3C,eAAe,EAAE,CACf,OAAO,EAAE,yBAAyB,KAC/B,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;CACtC,CAAC"}
+{"version":3,"file":"app-monitor.d.ts","sourceRoot":"","sources":["../src/app-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,eAAe,EAErB,MAAM,iCAAiC,CAAC;AAgTzC,QAAA,MAAM,qBAAqB,GACzB,MAAM,MAAM,EACZ,UAAU,MAAM,KACf,eAAe,GAAG,IAwEpB,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,mDAKrC;IACD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;CAC3C,KAAG,iBAgLH,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC;AACjC,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG;IAC3C,eAAe,EAAE,CACf,OAAO,EAAE,yBAAyB,KAC/B,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;CACtC,CAAC"}

package/dist/app-monitor.js

@@ -1,8 +1,17 @@
-import { escapeRegExp, getEmitter, logger, spawn, SubprocessError } from '@react-native-harness/tools';
+import { escapeRegExp, getEmitter, logger, spawn, SubprocessError, } 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, fromTime) => ['logcat', '-v', 'threadtime', '-b', 'crash', `--uid=${uid}`, '-T', fromTime];
+const getLogcatArgs = (uid, fromTime) => [
+    'logcat',
+    '-v',
+    'threadtime',
+    '-b',
+    'crash',
+    `--uid=${uid}`,
+    '-T',
+    fromTime,
+];
 const MAX_RECENT_LOG_LINES = 200;
 const MAX_RECENT_CRASH_ARTIFACTS = 10;
 const CRASH_ARTIFACT_SETTLE_DELAY_MS = 100;
@@ -29,7 +38,11 @@ const getAndroidLogLineCrashDetails = ({ line, bundleId, pid, }) => {
         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],
     };
@@ -116,7 +129,9 @@ const createCrashArtifact = ({ details, recentLogLines, }) => {
         triggerLine: details.summary ?? '',
         triggerOccurredAt,
         artifactType: 'logcat',
-        rawLines: rawLines.length > 0 ? rawLines : parsedDetails.rawLines ?? details.rawLines,
+        rawLines: rawLines.length > 0
+            ? rawLines
+            : parsedDetails.rawLines ?? details.rawLines,
     };
 };
 const persistCrashArtifact = ({ details, crashArtifactWriter, }) => {
@@ -151,7 +166,8 @@ const getLatestCrashArtifact = ({ crashArtifacts, recentLogLines, processName, p
         : matchingByProcess.length > 0
             ? matchingByProcess
             : crashArtifacts;
-    const sortedCandidates = [...candidates].sort((left, right) => Math.abs(left.occurredAt - occurredAt) - Math.abs(right.occurredAt - occurredAt));
+    const sortedCandidates = [...candidates].sort((left, right) => Math.abs(left.occurredAt - occurredAt) -
+        Math.abs(right.occurredAt - occurredAt));
     const artifact = sortedCandidates[0];
     if (!artifact) {
         return null;
@@ -235,7 +251,10 @@ export const createAndroidAppMonitor = ({ adbId, bundleId, appUid, crashArtifact
         emitter.emit(event);
     };
     const recordLogLine = (line) => {
-        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) => {
         if (!details) {
@@ -277,7 +296,8 @@ export const createAndroidAppMonitor = ({ adbId, bundleId, appUid, crashArtifact
                     emit({ type: 'log', source: 'logs', line });
                     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);

package/dist/assertions.d.ts

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1 @@
+{"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

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

package/dist/avd-config.d.ts

@@ -0,0 +1,41 @@
+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 declare const getAvdDirectory: (name: string) => string;
+export declare const getAvdConfigPath: (name: string) => string;
+export declare const parseAvdConfig: (contents: string) => AvdConfig;
+export declare const readAvdConfig: (name: string) => Promise<AvdConfig | null>;
+export declare const isAvdCompatible: ({ emulator, avdConfig, hostArch, }: {
+    emulator: AndroidEmulator;
+    avdConfig: AvdConfig;
+    hostArch: AndroidSystemImageArch;
+}) => AvdCompatibilityResult;
+export declare const getNormalizedAvdCacheConfig: ({ emulator, hostArch, }: {
+    emulator: AndroidEmulator;
+    hostArch: AndroidSystemImageArch;
+}) => {
+    name: string;
+    apiLevel: number;
+    arch: AndroidSystemImageArch;
+    profile: string;
+    diskSize: string;
+    heapSize: string;
+} | null;
+export declare const resolveAvdCachingEnabled: ({ avd, isInteractive, env, }: {
+    avd?: AndroidEmulatorAVDConfig;
+    isInteractive: boolean;
+    env?: NodeJS.ProcessEnv;
+}) => boolean;
+//# sourceMappingURL=avd-config.d.ts.map

package/dist/avd-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avd-config.d.ts","sourceRoot":"","sources":["../src/avd-config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAC/D,OAAO,KAAK,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAE7E,MAAM,MAAM,SAAS,GAAG;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAC9B;IAAE,UAAU,EAAE,IAAI,CAAA;CAAE,GACpB;IAAE,UAAU,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE1C,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,MAI9C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG,MAE/C,CAAC;AAkEF,eAAO,MAAM,cAAc,GAAI,UAAU,MAAM,KAAG,SAyCjD,CAAC;AAEF,eAAO,MAAM,aAAa,GACxB,MAAM,MAAM,KACX,OAAO,CAAC,SAAS,GAAG,IAAI,CAU1B,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,oCAI7B;IACD,QAAQ,EAAE,eAAe,CAAC;IAC1B,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,sBAAsB,CAAC;CAClC,KAAG,sBAmFH,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAI,yBAGzC;IACD,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,sBAAsB,CAAC;CAClC,KAAG;IACF,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,sBAAsB,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,IAeH,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,8BAItC;IACD,GAAG,CAAC,EAAE,wBAAwB,CAAC;IAC/B,aAAa,EAAE,OAAO,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB,KAAG,OAWH,CAAC"}

package/dist/avd-config.js

@@ -0,0 +1,173 @@
+import { access, readFile } from 'node:fs/promises';
+export const getAvdDirectory = (name) => {
+    return `${process.env.ANDROID_AVD_HOME ?? `${process.env.HOME}/.android/avd`}/${name}.avd`;
+};
+export const getAvdConfigPath = (name) => {
+    return `${getAvdDirectory(name)}/config.ini`;
+};
+const normalizeAvdValue = (value) => {
+    if (!value) {
+        return undefined;
+    }
+    return value.trim();
+};
+const normalizeConfigValue = (value) => {
+    return value.trim().toLowerCase();
+};
+const parseSizeInBytes = (value) => {
+    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) => {
+    const match = value?.match(/android-(\d+)/i);
+    return match ? Number(match[1]) : null;
+};
+const normalizeProfile = (value) => {
+    if (!value) {
+        return undefined;
+    }
+    return value
+        .trim()
+        .replace(/[\r\n]+/g, ' ')
+        .toLowerCase();
+};
+export const parseAvdConfig = (contents) => {
+    const config = {};
+    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) => {
+    const configPath = getAvdConfigPath(name);
+    try {
+        await access(configPath);
+    }
+    catch {
+        return null;
+    }
+    return parseAvdConfig(await readFile(configPath, 'utf8'));
+};
+export const isAvdCompatible = ({ emulator, avdConfig, hostArch, }) => {
+    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, }) => {
+    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, }) => {
+    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;
+};