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

package/dist/config.d.ts

@@ -11,16 +11,29 @@ export declare const AndroidEmulatorAVDConfigSchema: z.ZodObject<{
     profile: z.ZodString;
     diskSize: z.ZodDefault<z.ZodString>;
     heapSize: z.ZodDefault<z.ZodString>;
+    snapshot: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     apiLevel: number;
     profile: string;
     diskSize: string;
     heapSize: string;
+    snapshot?: {
+        enabled?: boolean | undefined;
+    } | undefined;
 }, {
     apiLevel: number;
     profile: string;
     diskSize?: string | undefined;
     heapSize?: string | undefined;
+    snapshot?: {
+        enabled?: boolean | undefined;
+    } | undefined;
 }>;
 export declare const AndroidEmulatorSchema: z.ZodObject<{
     type: z.ZodLiteral<"emulator">;
@@ -30,16 +43,29 @@ export declare const AndroidEmulatorSchema: z.ZodObject<{
         profile: z.ZodString;
         diskSize: z.ZodDefault<z.ZodString>;
         heapSize: z.ZodDefault<z.ZodString>;
+        snapshot: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled?: boolean | undefined;
+        }, {
+            enabled?: boolean | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         apiLevel: number;
         profile: string;
         diskSize: string;
         heapSize: string;
+        snapshot?: {
+            enabled?: boolean | undefined;
+        } | undefined;
     }, {
         apiLevel: number;
         profile: string;
         diskSize?: string | undefined;
         heapSize?: string | undefined;
+        snapshot?: {
+            enabled?: boolean | undefined;
+        } | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
@@ -49,6 +75,9 @@ export declare const AndroidEmulatorSchema: z.ZodObject<{
         profile: string;
         diskSize: string;
         heapSize: string;
+        snapshot?: {
+            enabled?: boolean | undefined;
+        } | undefined;
     } | undefined;
 }, {
     name: string;
@@ -58,6 +87,9 @@ export declare const AndroidEmulatorSchema: z.ZodObject<{
         profile: string;
         diskSize?: string | undefined;
         heapSize?: string | undefined;
+        snapshot?: {
+            enabled?: boolean | undefined;
+        } | undefined;
     } | undefined;
 }>;
 export declare const PhysicalAndroidDeviceSchema: z.ZodObject<{
@@ -81,16 +113,29 @@ export declare const AndroidDeviceSchema: z.ZodDiscriminatedUnion<"type", [z.Zod
         profile: z.ZodString;
         diskSize: z.ZodDefault<z.ZodString>;
         heapSize: z.ZodDefault<z.ZodString>;
+        snapshot: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            enabled?: boolean | undefined;
+        }, {
+            enabled?: boolean | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         apiLevel: number;
         profile: string;
         diskSize: string;
         heapSize: string;
+        snapshot?: {
+            enabled?: boolean | undefined;
+        } | undefined;
     }, {
         apiLevel: number;
         profile: string;
         diskSize?: string | undefined;
         heapSize?: string | undefined;
+        snapshot?: {
+            enabled?: boolean | undefined;
+        } | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     name: string;
@@ -100,6 +145,9 @@ export declare const AndroidDeviceSchema: z.ZodDiscriminatedUnion<"type", [z.Zod
         profile: string;
         diskSize: string;
         heapSize: string;
+        snapshot?: {
+            enabled?: boolean | undefined;
+        } | undefined;
     } | undefined;
 }, {
     name: string;
@@ -109,6 +157,9 @@ export declare const AndroidDeviceSchema: z.ZodDiscriminatedUnion<"type", [z.Zod
         profile: string;
         diskSize?: string | undefined;
         heapSize?: string | undefined;
+        snapshot?: {
+            enabled?: boolean | undefined;
+        } | undefined;
     } | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"physical">;
@@ -133,16 +184,29 @@ export declare const AndroidPlatformConfigSchema: z.ZodObject<{
             profile: z.ZodString;
             diskSize: z.ZodDefault<z.ZodString>;
             heapSize: z.ZodDefault<z.ZodString>;
+            snapshot: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                enabled?: boolean | undefined;
+            }, {
+                enabled?: boolean | undefined;
+            }>>;
         }, "strip", z.ZodTypeAny, {
             apiLevel: number;
             profile: string;
             diskSize: string;
             heapSize: string;
+            snapshot?: {
+                enabled?: boolean | undefined;
+            } | undefined;
         }, {
             apiLevel: number;
             profile: string;
             diskSize?: string | undefined;
             heapSize?: string | undefined;
+            snapshot?: {
+                enabled?: boolean | undefined;
+            } | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
         name: string;
@@ -152,6 +216,9 @@ export declare const AndroidPlatformConfigSchema: z.ZodObject<{
             profile: string;
             diskSize: string;
             heapSize: string;
+            snapshot?: {
+                enabled?: boolean | undefined;
+            } | undefined;
         } | undefined;
     }, {
         name: string;
@@ -161,6 +228,9 @@ export declare const AndroidPlatformConfigSchema: z.ZodObject<{
             profile: string;
             diskSize?: string | undefined;
             heapSize?: string | undefined;
+            snapshot?: {
+                enabled?: boolean | undefined;
+            } | undefined;
         } | undefined;
     }>, z.ZodObject<{
         type: z.ZodLiteral<"physical">;
@@ -194,6 +264,9 @@ export declare const AndroidPlatformConfigSchema: z.ZodObject<{
             profile: string;
             diskSize: string;
             heapSize: string;
+            snapshot?: {
+                enabled?: boolean | undefined;
+            } | undefined;
         } | undefined;
     } | {
         manufacturer: string;
@@ -215,6 +288,9 @@ export declare const AndroidPlatformConfigSchema: z.ZodObject<{
             profile: string;
             diskSize?: string | undefined;
             heapSize?: string | undefined;
+            snapshot?: {
+                enabled?: boolean | undefined;
+            } | undefined;
         } | undefined;
     } | {
         manufacturer: string;
@@ -233,6 +309,7 @@ export type AndroidDevice = z.infer<typeof AndroidDeviceSchema>;
 export type AndroidPlatformConfig = z.infer<typeof AndroidPlatformConfigSchema>;
 export type AndroidAppLaunchOptions = z.infer<typeof AndroidAppLaunchOptionsSchema>;
 export type AndroidEmulatorAVDConfig = z.infer<typeof AndroidEmulatorAVDConfigSchema>;
+export type AndroidEmulatorAVDSnapshotConfig = NonNullable<AndroidEmulatorAVDConfig['snapshot']>;
 export declare const isAndroidDeviceEmulator: (device: AndroidDevice) => device is AndroidEmulator;
 export declare const isAndroidDevicePhysical: (device: AndroidDevice) => device is PhysicalAndroidDevice;
 export declare function assertAndroidDeviceEmulator(device: AndroidDevice): asserts device is AndroidEmulator;

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,6BAA6B;;;;;;EAIxC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;EAKzC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIhC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;EAItC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG9B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAStC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,aAAa,KACpB,MAAM,IAAI,eAEZ,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,aAAa,KACpB,MAAM,IAAI,qBAEZ,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,MAAM,IAAI,eAAe,CAInC;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,MAAM,IAAI,qBAAqB,CAIzC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,6BAA6B;;;;;;EAIxC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUzC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIhC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;EAItC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG9B,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAStC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,6BAA6B,CACrC,CAAC;AACF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAC;AACF,MAAM,MAAM,gCAAgC,GAAG,WAAW,CACxD,wBAAwB,CAAC,UAAU,CAAC,CACrC,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,aAAa,KACpB,MAAM,IAAI,eAEZ,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,QAAQ,aAAa,KACpB,MAAM,IAAI,qBAEZ,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,MAAM,IAAI,eAAe,CAInC;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,MAAM,IAAI,qBAAqB,CAIzC"}

package/dist/config.js

@@ -9,6 +9,11 @@ export const AndroidEmulatorAVDConfigSchema = z.object({
     profile: z.string().min(1, 'Profile is required'),
     diskSize: z.string().min(1, 'Disk size is required').default('1G'),
     heapSize: z.string().min(1, 'Heap size is required').default('1G'),
+    snapshot: z
+        .object({
+        enabled: z.boolean().optional(),
+    })
+        .optional(),
 });
 export const AndroidEmulatorSchema = z.object({
     type: z.literal('emulator'),

package/dist/emulator-startup.d.ts

@@ -0,0 +1,3 @@
+export type EmulatorBootMode = 'default-boot' | 'clean-snapshot-generation' | 'snapshot-reuse';
+export declare const getEmulatorStartupArgs: (name: string, mode: EmulatorBootMode) => string[];
+//# sourceMappingURL=emulator-startup.d.ts.map

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

@@ -0,0 +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;AAYrB,eAAO,MAAM,sBAAsB,GACjC,MAAM,MAAM,EACZ,MAAM,gBAAgB,KACrB,MAAM,EASR,CAAC"}

package/dist/emulator-startup.js

@@ -0,0 +1,17 @@
+const COMMON_EMULATOR_ARGS = [
+    '-no-window',
+    '-gpu',
+    'swiftshader_indirect',
+    '-noaudio',
+    '-no-boot-anim',
+    '-camera-back',
+    'none',
+];
+export const getEmulatorStartupArgs = (name, mode) => {
+    const modeArgs = mode === 'clean-snapshot-generation'
+        ? ['-no-snapshot-load']
+        : mode === 'snapshot-reuse'
+            ? ['-no-snapshot-save']
+            : ['-no-snapshot-load', '-no-snapshot-save'];
+    return [`@${name}`, ...modeArgs, ...COMMON_EMULATOR_ARGS];
+};

package/dist/emulator.d.ts

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

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

@@ -0,0 +1,27 @@
+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/environment.d.ts

@@ -0,0 +1,31 @@
+export type AndroidSystemImageArch = 'x86_64' | 'arm64-v8a' | 'armeabi-v7a';
+type AndroidSdkRootOptions = {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    homeDirectory?: string;
+};
+export declare const getDefaultUnixAndroidSdkRoot: ({ platform, homeDirectory, }?: Omit<AndroidSdkRootOptions, "env">) => string | null;
+export declare const getAndroidSdkRoot: (env?: NodeJS.ProcessEnv, options?: Omit<AndroidSdkRootOptions, "env">) => string | null;
+export declare const getHostAndroidSystemImageArch: (architecture?: string) => AndroidSystemImageArch;
+export declare const getAndroidPlatformPackage: (apiLevel: number) => string;
+export declare const getAndroidSystemImagePackage: (apiLevel: number, architecture?: AndroidSystemImageArch) => string;
+export declare const getRequiredAndroidSdkPackages: ({ apiLevel, includeEmulator, architecture, }?: {
+    apiLevel?: number;
+    includeEmulator?: boolean;
+    architecture?: AndroidSystemImageArch;
+}) => string[];
+export declare const ensureAndroidSdkPackages: (packages: readonly string[], { env, platform, homeDirectory, }?: AndroidSdkRootOptions) => Promise<string>;
+export declare const ensureAndroidAdbAvailable: (options?: AndroidSdkRootOptions) => Promise<string>;
+export declare const ensureAndroidEmulatorAvailable: (options?: AndroidSdkRootOptions) => Promise<string>;
+export declare const ensureAndroidAvdProvisioningAvailable: (apiLevel: number, architecture?: AndroidSystemImageArch, options?: AndroidSdkRootOptions) => Promise<string>;
+export declare const ensureAndroidDiscoveryEnvironment: () => Promise<string>;
+export declare const ensureAndroidPhysicalDeviceEnvironment: () => Promise<string>;
+export declare const ensureAndroidEmulatorEnvironment: (apiLevel: number) => Promise<string>;
+export declare const getAndroidProcessEnv: (env?: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;
+export declare const initializeAndroidProcessEnv: () => void;
+export declare const getAdbBinaryPath: (sdkRoot?: string) => string;
+export declare const getEmulatorBinaryPath: (sdkRoot?: string) => string;
+export declare const getSdkManagerBinaryPath: (sdkRoot?: string) => string;
+export declare const getAvdManagerBinaryPath: (sdkRoot?: string) => string;
+export {};
+//# sourceMappingURL=environment.d.ts.map

package/dist/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../src/environment.ts"],"names":[],"mappings":"AAcA,MAAM,MAAM,sBAAsB,GAAG,QAAQ,GAAG,WAAW,GAAG,aAAa,CAAC;AAE5E,KAAK,qBAAqB,GAAG;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAQF,eAAO,MAAM,4BAA4B,GAAI,+BAG1C,IAAI,CAAC,qBAAqB,EAAE,KAAK,CAAM,KAAG,MAAM,GAAG,IAUrD,CAAC;AAwRF,eAAO,MAAM,iBAAiB,GAC5B,MAAK,MAAM,CAAC,UAAwB,EACpC,UAAS,IAAI,CAAC,qBAAqB,EAAE,KAAK,CAAM,KAC/C,MAAM,GAAG,IAIX,CAAC;AAiBF,eAAO,MAAM,6BAA6B,GACxC,eAAc,MAAqB,KAClC,sBAUF,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAI,UAAU,MAAM,KAAG,MAE5D,CAAC;AAEF,eAAO,MAAM,4BAA4B,GACvC,UAAU,MAAM,EAChB,eAAc,sBAAwD,KACrE,MAEF,CAAC;AAEF,eAAO,MAAM,6BAA6B,GAAI,+CAI3C;IACD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,YAAY,CAAC,EAAE,sBAAsB,CAAC;CAClC,KAAG,MAAM,EAed,CAAC;AAoBF,eAAO,MAAM,wBAAwB,GACnC,UAAU,SAAS,MAAM,EAAE,EAC3B,oCAIG,qBAA0B,KAC5B,OAAO,CAAC,MAAM,CA8BhB,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,UAAS,qBAA0B,KAClC,OAAO,CAAC,MAAM,CAEhB,CAAC;AAEF,eAAO,MAAM,8BAA8B,GACzC,UAAS,qBAA0B,KAClC,OAAO,CAAC,MAAM,CAEhB,CAAC;AAEF,eAAO,MAAM,qCAAqC,GAChD,UAAU,MAAM,EAChB,eAAc,sBAAwD,EACtE,UAAS,qBAA0B,KAClC,OAAO,CAAC,MAAM,CAQhB,CAAC;AAEF,eAAO,MAAM,iCAAiC,QAAa,OAAO,CAAC,MAAM,CAIxE,CAAC;AAEF,eAAO,MAAM,sCAAsC,QACvC,OAAO,CAAC,MAAM,CAIvB,CAAC;AAEJ,eAAO,MAAM,gCAAgC,GAC3C,UAAU,MAAM,KACf,OAAO,CAAC,MAAM,CAOhB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,MAAK,MAAM,CAAC,UAAwB,KACnC,MAAM,CAAC,UA2BT,CAAC;AAEF,eAAO,MAAM,2BAA2B,QAAO,IAE9C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,UAAS,MAAoC,KAC5C,MAAqD,CAAC;AAEzD,eAAO,MAAM,qBAAqB,GAChC,UAAS,MAAoC,KAC5C,MAAoD,CAAC;AAExD,eAAO,MAAM,uBAAuB,GAClC,UAAS,MAAoC,KAC5C,MACsE,CAAC;AAE1E,eAAO,MAAM,uBAAuB,GAClC,UAAS,MAAoC,KAC5C,MACsE,CAAC"}

package/dist/environment.js

@@ -0,0 +1,317 @@
+import { spawn } from '@react-native-harness/tools';
+import { logger } from '@react-native-harness/tools';
+import { createWriteStream } from 'node:fs';
+import { access, cp, mkdir, mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import https from 'node:https';
+const CMDLINE_TOOLS_PATH_SEGMENTS = ['cmdline-tools', 'latest'];
+const ANDROID_REPOSITORY_INDEX_URL = 'https://dl.google.com/android/repository/repository2-1.xml';
+const androidEnvironmentLogger = logger.child('android-environment');
+const getConfiguredAndroidSdkRoot = (env = process.env) => {
+    return env.ANDROID_HOME ?? env.ANDROID_SDK_ROOT ?? null;
+};
+export const getDefaultUnixAndroidSdkRoot = ({ platform = process.platform, homeDirectory = os.homedir(), } = {}) => {
+    if (platform === 'darwin') {
+        return path.join(homeDirectory, 'Library', 'Android', 'sdk');
+    }
+    if (platform === 'linux') {
+        return path.join(homeDirectory, 'Android', 'Sdk');
+    }
+    return null;
+};
+const canBootstrapAndroidSdk = (platform = process.platform) => {
+    return platform === 'darwin' || platform === 'linux';
+};
+const pathExists = async (filePath) => {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const quoteShell = (value) => {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+};
+const downloadText = async (url) => {
+    return new Promise((resolve, reject) => {
+        const request = https.get(url, (response) => {
+            const { statusCode = 0, headers } = response;
+            if (statusCode >= 300 &&
+                statusCode < 400 &&
+                typeof headers.location === 'string') {
+                response.resume();
+                resolve(downloadText(headers.location));
+                return;
+            }
+            if (statusCode !== 200) {
+                response.resume();
+                reject(new Error(`Failed to download Android repository index from ${url} (status ${statusCode}).`));
+                return;
+            }
+            response.setEncoding('utf8');
+            let body = '';
+            response.on('data', (chunk) => {
+                body += chunk;
+            });
+            response.once('end', () => {
+                resolve(body);
+            });
+        });
+        request.once('error', reject);
+    });
+};
+const downloadFile = async (url, destinationPath) => {
+    await new Promise((resolve, reject) => {
+        const request = https.get(url, (response) => {
+            const { statusCode = 0, headers } = response;
+            if (statusCode >= 300 &&
+                statusCode < 400 &&
+                typeof headers.location === 'string') {
+                response.resume();
+                resolve(downloadFile(headers.location, destinationPath));
+                return;
+            }
+            if (statusCode !== 200) {
+                response.resume();
+                reject(new Error(`Failed to download Android command-line tools from ${url} (status ${statusCode}).`));
+                return;
+            }
+            const output = createWriteStream(destinationPath);
+            pipeline(response, output).then(resolve).catch(reject);
+        });
+        request.once('error', reject);
+    });
+};
+const getCommandLineToolsArchiveUrl = async (platform = process.platform) => {
+    const archivePlatform = platform === 'darwin' ? 'mac' : platform === 'linux' ? 'linux' : null;
+    if (!archivePlatform) {
+        throw new Error('Automatic Android SDK bootstrap is only supported on macOS and Linux.');
+    }
+    const repositoryIndex = await downloadText(ANDROID_REPOSITORY_INDEX_URL);
+    const archivePattern = new RegExp(`commandlinetools-${archivePlatform}-(\\d+)_latest\\.zip`, 'g');
+    const matches = [...repositoryIndex.matchAll(archivePattern)];
+    if (matches.length === 0) {
+        throw new Error(`Failed to resolve Android command-line tools archive for ${archivePlatform}.`);
+    }
+    const newestArchive = matches
+        .map((match) => ({
+        fileName: match[0],
+        revision: Number(match[1]),
+    }))
+        .sort((left, right) => right.revision - left.revision)[0];
+    return `https://dl.google.com/android/repository/${newestArchive.fileName}`;
+};
+const ensureAndroidCommandLineTools = async (sdkRoot, platform = process.platform) => {
+    if ((await pathExists(getSdkManagerBinaryPath(sdkRoot))) &&
+        (await pathExists(getAvdManagerBinaryPath(sdkRoot)))) {
+        return;
+    }
+    if (!canBootstrapAndroidSdk(platform)) {
+        throw new Error('Android command-line tools are missing. Set ANDROID_HOME or ANDROID_SDK_ROOT to an initialized SDK.');
+    }
+    androidEnvironmentLogger.info('Bootstrapping Android command-line tools in %s', sdkRoot);
+    await mkdir(sdkRoot, { recursive: true });
+    const temporaryDirectory = await mkdtemp(path.join(os.tmpdir(), 'android-cmdline-tools-'));
+    const archivePath = path.join(temporaryDirectory, 'cmdline-tools.zip');
+    const extractedPath = path.join(temporaryDirectory, 'extracted');
+    const sourceDirectory = path.join(extractedPath, 'cmdline-tools');
+    const targetDirectory = path.join(sdkRoot, ...CMDLINE_TOOLS_PATH_SEGMENTS);
+    try {
+        await downloadFile(await getCommandLineToolsArchiveUrl(platform), archivePath);
+        await spawn('unzip', ['-q', archivePath, '-d', extractedPath]);
+        await rm(targetDirectory, { force: true, recursive: true });
+        await mkdir(path.dirname(targetDirectory), { recursive: true });
+        await cp(sourceDirectory, targetDirectory, { recursive: true });
+    }
+    finally {
+        await rm(temporaryDirectory, { force: true, recursive: true });
+    }
+};
+const acceptAndroidLicenses = async (sdkRoot) => {
+    const sdkManagerBinaryPath = getSdkManagerBinaryPath(sdkRoot);
+    await spawn('bash', [
+        '-lc',
+        `yes | ${quoteShell(sdkManagerBinaryPath)} --sdk_root=${quoteShell(sdkRoot)} --licenses >/dev/null`,
+    ], {
+        env: getAndroidProcessEnv({
+            ...process.env,
+            ANDROID_HOME: sdkRoot,
+            ANDROID_SDK_ROOT: sdkRoot,
+        }),
+    });
+};
+const getPackageVerificationPath = (sdkRoot, packageName) => {
+    if (packageName === 'platform-tools') {
+        return getAdbBinaryPath(sdkRoot);
+    }
+    if (packageName === 'emulator') {
+        return getEmulatorBinaryPath(sdkRoot);
+    }
+    if (packageName.startsWith('platforms;android-')) {
+        return path.join(sdkRoot, packageName.replace(';', '/'));
+    }
+    if (packageName.startsWith('system-images;android-')) {
+        return path.join(sdkRoot, packageName.replaceAll(';', path.sep));
+    }
+    return null;
+};
+const getMissingAndroidSdkPackages = async (sdkRoot, packages) => {
+    const missingPackages = [];
+    for (const packageName of packages) {
+        const verificationPath = getPackageVerificationPath(sdkRoot, packageName);
+        if (!verificationPath) {
+            continue;
+        }
+        if (!(await pathExists(verificationPath))) {
+            missingPackages.push(packageName);
+        }
+    }
+    return missingPackages;
+};
+const installAndroidSdkPackages = async (sdkRoot, packages) => {
+    if (packages.length === 0) {
+        return;
+    }
+    const sdkManagerBinaryPath = getSdkManagerBinaryPath(sdkRoot);
+    const packageArgs = packages
+        .map((packageName) => quoteShell(packageName))
+        .join(' ');
+    androidEnvironmentLogger.info('Installing missing Android SDK packages: %s', packages.join(', '));
+    await acceptAndroidLicenses(sdkRoot);
+    await spawn('bash', [
+        '-lc',
+        `yes | ${quoteShell(sdkManagerBinaryPath)} --sdk_root=${quoteShell(sdkRoot)} ${packageArgs}`,
+    ], {
+        env: getAndroidProcessEnv({
+            ...process.env,
+            ANDROID_HOME: sdkRoot,
+            ANDROID_SDK_ROOT: sdkRoot,
+        }),
+    });
+};
+export const getAndroidSdkRoot = (env = process.env, options = {}) => {
+    return (getConfiguredAndroidSdkRoot(env) ?? getDefaultUnixAndroidSdkRoot(options));
+};
+const getRequiredAndroidSdkRoot = (env = process.env, options = {}) => {
+    const sdkRoot = getAndroidSdkRoot(env, options);
+    if (!sdkRoot) {
+        throw new Error('Android SDK root is not configured. Set ANDROID_HOME or ANDROID_SDK_ROOT.');
+    }
+    return sdkRoot;
+};
+export const getHostAndroidSystemImageArch = (architecture = process.arch) => {
+    switch (architecture) {
+        case 'arm64':
+            return 'arm64-v8a';
+        case 'arm':
+            return 'armeabi-v7a';
+        case 'x64':
+        default:
+            return 'x86_64';
+    }
+};
+export const getAndroidPlatformPackage = (apiLevel) => {
+    return `platforms;android-${apiLevel}`;
+};
+export const getAndroidSystemImagePackage = (apiLevel, architecture = getHostAndroidSystemImageArch()) => {
+    return `system-images;android-${apiLevel};default;${architecture}`;
+};
+export const getRequiredAndroidSdkPackages = ({ apiLevel, includeEmulator = false, architecture = getHostAndroidSystemImageArch(), } = {}) => {
+    const packages = ['platform-tools'];
+    if (!includeEmulator) {
+        return packages;
+    }
+    packages.push('emulator');
+    if (typeof apiLevel === 'number') {
+        packages.push(getAndroidPlatformPackage(apiLevel));
+        packages.push(getAndroidSystemImagePackage(apiLevel, architecture));
+    }
+    return packages;
+};
+const getMissingAndroidSdkPackagesForEnvironment = async (packages, { env = process.env, platform = process.platform, homeDirectory = os.homedir(), } = {}) => {
+    const sdkRoot = getRequiredAndroidSdkRoot(env, { platform, homeDirectory });
+    await mkdir(sdkRoot, { recursive: true });
+    return {
+        sdkRoot,
+        missingPackages: await getMissingAndroidSdkPackages(sdkRoot, packages),
+    };
+};
+export const ensureAndroidSdkPackages = async (packages, { env = process.env, platform = process.platform, homeDirectory = os.homedir(), } = {}) => {
+    const { sdkRoot, missingPackages } = await getMissingAndroidSdkPackagesForEnvironment(packages, {
+        env,
+        platform,
+        homeDirectory,
+    });
+    if (missingPackages.length === 0) {
+        return sdkRoot;
+    }
+    await ensureAndroidCommandLineTools(sdkRoot, platform);
+    await installAndroidSdkPackages(sdkRoot, missingPackages);
+    const unresolvedPackages = await getMissingAndroidSdkPackages(sdkRoot, packages);
+    if (unresolvedPackages.length > 0) {
+        throw new Error(`Android SDK packages are still missing after installation: ${unresolvedPackages.join(', ')}`);
+    }
+    return sdkRoot;
+};
+export const ensureAndroidAdbAvailable = async (options = {}) => {
+    return ensureAndroidSdkPackages(['platform-tools'], options);
+};
+export const ensureAndroidEmulatorAvailable = async (options = {}) => {
+    return ensureAndroidSdkPackages(['emulator'], options);
+};
+export const ensureAndroidAvdProvisioningAvailable = async (apiLevel, architecture = getHostAndroidSystemImageArch(), options = {}) => {
+    return ensureAndroidSdkPackages([
+        getAndroidPlatformPackage(apiLevel),
+        getAndroidSystemImagePackage(apiLevel, architecture),
+    ], options);
+};
+export const ensureAndroidDiscoveryEnvironment = async () => {
+    initializeAndroidProcessEnv();
+    return ensureAndroidAdbAvailable();
+};
+export const ensureAndroidPhysicalDeviceEnvironment = async () => {
+    initializeAndroidProcessEnv();
+    return ensureAndroidAdbAvailable();
+};
+export const ensureAndroidEmulatorEnvironment = async (apiLevel) => {
+    initializeAndroidProcessEnv();
+    await ensureAndroidAdbAvailable();
+    await ensureAndroidEmulatorAvailable();
+    return ensureAndroidAvdProvisioningAvailable(apiLevel);
+};
+export const getAndroidProcessEnv = (env = process.env) => {
+    const sdkRoot = getAndroidSdkRoot(env);
+    if (!sdkRoot) {
+        return env;
+    }
+    const platformToolsPath = path.join(sdkRoot, 'platform-tools');
+    const emulatorPath = path.join(sdkRoot, 'emulator');
+    const cmdlineToolsPath = path.join(sdkRoot, ...CMDLINE_TOOLS_PATH_SEGMENTS);
+    const cmdlineToolsBinPath = path.join(cmdlineToolsPath, 'bin');
+    const currentPath = env.PATH ?? '';
+    const pathEntries = [
+        platformToolsPath,
+        emulatorPath,
+        cmdlineToolsPath,
+        cmdlineToolsBinPath,
+        currentPath,
+    ].filter((entry) => entry !== '');
+    return {
+        ...env,
+        ANDROID_HOME: sdkRoot,
+        ANDROID_SDK_ROOT: sdkRoot,
+        ANDROID_AVD_HOME: path.join(os.homedir(), '.android', 'avd'),
+        PATH: pathEntries.join(path.delimiter),
+    };
+};
+export const initializeAndroidProcessEnv = () => {
+    Object.assign(process.env, getAndroidProcessEnv());
+};
+export const getAdbBinaryPath = (sdkRoot = getRequiredAndroidSdkRoot()) => path.join(sdkRoot, 'platform-tools', 'adb');
+export const getEmulatorBinaryPath = (sdkRoot = getRequiredAndroidSdkRoot()) => path.join(sdkRoot, 'emulator', 'emulator');
+export const getSdkManagerBinaryPath = (sdkRoot = getRequiredAndroidSdkRoot()) => path.join(sdkRoot, ...CMDLINE_TOOLS_PATH_SEGMENTS, 'bin', 'sdkmanager');
+export const getAvdManagerBinaryPath = (sdkRoot = getRequiredAndroidSdkRoot()) => path.join(sdkRoot, ...CMDLINE_TOOLS_PATH_SEGMENTS, 'bin', 'avdmanager');

package/dist/errors.d.ts

@@ -0,0 +1,7 @@
+export declare class HarnessAppPathError extends Error {
+    constructor(reason: 'missing' | 'invalid', appPath?: string);
+}
+export declare class HarnessEmulatorConfigError extends Error {
+    constructor(deviceName: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,MAAM,EAAE,SAAS,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM;CAQ5D;AAED,qBAAa,0BAA2B,SAAQ,KAAK;gBACvC,UAAU,EAAE,MAAM;CAM/B"}

package/dist/errors.js

@@ -0,0 +1,14 @@
+export class HarnessAppPathError extends Error {
+    constructor(reason, appPath) {
+        super(reason === 'missing'
+            ? 'App is not installed on the emulator and HARNESS_APP_PATH is not set.'
+            : `HARNESS_APP_PATH points to a missing APK: ${appPath ?? '<unknown>'}`);
+        this.name = 'HarnessAppPathError';
+    }
+}
+export class HarnessEmulatorConfigError extends Error {
+    constructor(deviceName) {
+        super(`Android emulator "${deviceName}" is not running and no AVD config was provided. Add the "avd" property to this runner config so Harness can create and boot the emulator.`);
+        this.name = 'HarnessEmulatorConfigError';
+    }
+}