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

package/src/adb.ts

@@ -1,9 +1,14 @@
 import { type AndroidAppLaunchOptions } from '@react-native-harness/platforms';
-import { spawn, SubprocessError } from '@react-native-harness/tools';
+import { logger, spawn, SubprocessError } from '@react-native-harness/tools';
 import { spawn as nodeSpawn } from 'node:child_process';
 import type { ChildProcessByStdio } from 'node:child_process';
 import { access, rm } from 'node:fs/promises';
 import type { Readable } from 'node:stream';
+import {
+  getAvdConfigPath,
+  getAvdDirectory,
+  readAvdConfig,
+} from './avd-config.js';
 import {
   ensureAndroidEmulatorAvailable,
   ensureAndroidSdkPackages,
@@ -18,6 +23,10 @@ import {
   getEmulatorStartupArgs,
   type EmulatorBootMode,
 } from './emulator-startup.js';
+import {
+  AdbAppNotInstalledError,
+  AdbPermissionGrantError,
+} from './adb-errors.js';
 
 const wait = async (ms: number): Promise<void> => {
   await new Promise((resolve) => {
@@ -52,13 +61,9 @@ const waitWithSignal = async (
   await Promise.race([wait(ms), waitForAbort(signal)]);
 };
 
-const getAvdConfigPath = (name: string): string =>
-  `${
-    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;
+const androidAdbLogger = logger.child('android-adb');
 
 export const emulatorProcess = {
   startDetachedProcess: (
@@ -160,6 +165,68 @@ export const verifyAndroidEmulatorSdk = async (
   await ensureAndroidSdkPackages(getRequiredEmulatorPackages(apiLevel));
 };
 
+const listAvdProfiles = async (): Promise<string[]> => {
+  const { stdout } = await spawn(getAvdManagerBinaryPath(), ['list', 'device']);
+
+  return stdout
+    .split('\n')
+    .map((line) => line.match(/^id:\s+\d+\s+or\s+"([^"]+)"/i)?.[1]?.trim())
+    .filter((profile): profile is string => profile != null && profile !== '');
+};
+
+const ensureAvdProfileAvailable = async (profile: string): Promise<void> => {
+  const availableProfiles = await listAvdProfiles();
+
+  if (availableProfiles.includes(profile)) {
+    return;
+  }
+
+  const availableProfilesList =
+    availableProfiles.length > 0
+      ? availableProfiles.join(', ')
+      : 'None reported by avdmanager.';
+
+  throw new Error(
+    `Android AVD profile "${profile}" is not available on this machine. Available profiles: ${availableProfilesList}`,
+  );
+};
+
+const ensureAvdConfigExists = async (name: string): Promise<string> => {
+  const configPath = getAvdConfigPath(name);
+
+  if ((await readAvdConfig(name)) == null) {
+    throw new Error(
+      `Android AVD "${name}" was created, but config.ini was not found at ${configPath}.`,
+    );
+  }
+
+  return configPath;
+};
+
+const getAvdIniPath = (name: string): string => {
+  const avdHome =
+    process.env.ANDROID_AVD_HOME ?? `${process.env.HOME}/.android/avd`;
+  return `${avdHome}/${name}.ini`;
+};
+
+const ensureAvdIniExists = async ({
+  name,
+  apiLevel,
+}: {
+  name: string;
+  apiLevel: number;
+}): Promise<string> => {
+  const iniPath = getAvdIniPath(name);
+
+  const avdDirectory = getAvdDirectory(name);
+  await spawn('bash', [
+    '-lc',
+    `printf '%s\n%s\n%s\n%s\n' 'avd.ini.encoding=UTF-8' 'path=${avdDirectory}' 'path.rel=avd/${name}.avd' 'target=android-${apiLevel}' > "${iniPath}"`,
+  ]);
+
+  return iniPath;
+};
+
 export const getStartAppArgs = (
   bundleId: string,
   activityName: string,
@@ -312,6 +379,79 @@ export const getDeviceInfo = async (
   return { manufacturer, model };
 };
 
+const getRequestedPermissions = async (
+  adbId: string,
+  bundleId: string,
+): Promise<string[]> => {
+  const { stdout } = await spawn(getAdbBinaryPath(), [
+    '-s',
+    adbId,
+    'shell',
+    'dumpsys',
+    'package',
+    bundleId,
+  ]);
+
+  const requestedPermissions = new Set<string>();
+  const lines = stdout.split('\n');
+  let inRequestedPermissionsSection = false;
+
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+
+    if (trimmedLine === 'requested permissions:') {
+      inRequestedPermissionsSection = true;
+      continue;
+    }
+
+    if (!inRequestedPermissionsSection) {
+      continue;
+    }
+
+    if (trimmedLine === '') {
+      continue;
+    }
+
+    if (trimmedLine.endsWith(':')) {
+      break;
+    }
+
+    if (/^[a-zA-Z0-9_.]+$/.test(trimmedLine)) {
+      requestedPermissions.add(trimmedLine);
+      continue;
+    }
+
+    break;
+  }
+
+  return [...requestedPermissions];
+};
+
+const getDangerousPermissions = async (adbId: string): Promise<Set<string>> => {
+  const { stdout } = await spawn(getAdbBinaryPath(), [
+    '-s',
+    adbId,
+    'shell',
+    'pm',
+    'list',
+    'permissions',
+    '-g',
+    '-d',
+  ]);
+
+  const dangerousPermissions = new Set<string>();
+
+  for (const match of stdout.matchAll(/permission:([a-zA-Z0-9_.]+)/g)) {
+    const permission = match[1]?.trim();
+
+    if (permission) {
+      dangerousPermissions.add(permission);
+    }
+  }
+
+  return dangerousPermissions;
+};
+
 export const isBootCompleted = async (adbId: string): Promise<boolean> => {
   try {
     const bootCompleted = await getShellProperty(adbId, 'sys.boot_completed');
@@ -336,6 +476,13 @@ export const installApp = async (
   await spawn(getAdbBinaryPath(), ['-s', adbId, 'install', '-r', appPath]);
 };
 
+export const uninstallApp = async (
+  adbId: string,
+  bundleId: string,
+): Promise<void> => {
+  await spawn(getAdbBinaryPath(), ['-s', adbId, 'uninstall', bundleId]);
+};
+
 export const hasAvd = async (name: string): Promise<boolean> => {
   const avds = await getAvds();
   return avds.includes(name);
@@ -354,15 +501,16 @@ export const createAvd = async ({
   );
 
   await verifyAndroidEmulatorSdk(apiLevel);
+  await ensureAvdProfileAvailable(profile);
   await spawn('bash', [
     '-lc',
-    `printf 'no\n' | "${getAvdManagerBinaryPath()}" create avd --force --name "${name}" --package "${systemImagePackage}" --device "${profile}"`,
+    `printf 'no\n' | "${getAvdManagerBinaryPath()}" create avd --force --name "${name}" --package "${systemImagePackage}" --device "${profile}" -p "${getAvdDirectory(name)}"`,
   ]);
+  await ensureAvdIniExists({ name, apiLevel });
+  const configPath = await ensureAvdConfigExists(name);
   await spawn('bash', [
     '-lc',
-    `printf '%s\n%s\n' 'disk.dataPartition.size=${diskSize}' 'vm.heapSize=${heapSize}' >> "${getAvdConfigPath(
-      name,
-    )}"`,
+    `printf '%s\n%s\n' 'disk.dataPartition.size=${diskSize}' 'vm.heapSize=${heapSize}' >> "${configPath}"`,
   ]);
 };
 
@@ -667,3 +815,77 @@ export const getConnectedDevices = async (): Promise<AdbDevice[]> => {
 
   return devices;
 };
+
+export const grantPermissions = async (
+  adbId: string,
+  bundleId: string,
+): Promise<void> => {
+  androidAdbLogger.debug('grantPermissions:start %o', {
+    adbId,
+    bundleId,
+  });
+
+  const isInstalled = await isAppInstalled(adbId, bundleId);
+  if (!isInstalled) {
+    throw new AdbAppNotInstalledError(bundleId, adbId);
+  }
+
+  const [requestedPermissions, dangerousPermissions] = await Promise.all([
+    getRequestedPermissions(adbId, bundleId),
+    getDangerousPermissions(adbId),
+  ]);
+  const permissions = requestedPermissions.filter((permission) =>
+    dangerousPermissions.has(permission),
+  );
+
+  androidAdbLogger.debug('grantPermissions:resolved %o', {
+    adbId,
+    bundleId,
+    requestedPermissions,
+    permissions,
+  });
+
+  if (permissions.length === 0) {
+    androidAdbLogger.debug('grantPermissions:skip %o', {
+      adbId,
+      bundleId,
+    });
+    return;
+  }
+
+  const grantCommands = permissions.map((permission) => [
+    '-s',
+    adbId,
+    'shell',
+    'pm',
+    'grant',
+    bundleId,
+    permission,
+  ]);
+
+  try {
+    androidAdbLogger.debug('grantPermissions:commands %o', {
+      adbId,
+      bundleId,
+      grantCommands,
+    });
+
+    await Promise.all(
+      grantCommands.map((args) => spawn(getAdbBinaryPath(), args as string[])),
+    );
+
+    androidAdbLogger.debug('grantPermissions:success %o', {
+      adbId,
+      bundleId,
+      permissions,
+    });
+  } catch (error) {
+    androidAdbLogger.debug('grantPermissions:error %o', {
+      adbId,
+      bundleId,
+      permissions,
+      error,
+    });
+    throw new AdbPermissionGrantError(bundleId, permissions, adbId);
+  }
+};

package/src/emulator-startup.ts

@@ -9,8 +9,6 @@ const COMMON_EMULATOR_ARGS = [
   'swiftshader_indirect',
   '-noaudio',
   '-no-boot-anim',
-  '-camera-back',
-  'none',
 ] as const;
 
 export const getEmulatorStartupArgs = (

package/src/instance.ts

@@ -59,6 +59,20 @@ const getHarnessAppPath = (): string => {
   return appPath;
 };
 
+const getOptionalHarnessAppPath = (): string | undefined => {
+  const appPath = process.env.HARNESS_APP_PATH;
+
+  if (!appPath) {
+    return undefined;
+  }
+
+  if (!fs.existsSync(appPath)) {
+    throw new HarnessAppPathError('invalid', appPath);
+  }
+
+  return appPath;
+};
+
 const configureAndroidRuntime = async (
   adbId: string,
   config: AndroidPlatformConfig,
@@ -180,6 +194,7 @@ export const getAndroidEmulatorPlatformInstance = async (
 ): Promise<HarnessPlatformRunner> => {
   assertAndroidDeviceEmulator(config.device);
   const detectNativeCrashes = harnessConfig.detectNativeCrashes ?? true;
+  const permissionsEnabled = harnessConfig.permissions ?? false;
   const emulatorConfig = config.device;
   const emulatorName = emulatorConfig.name;
   const avdConfig = emulatorConfig.avd;
@@ -250,14 +265,22 @@ export const getAndroidEmulatorPlatformInstance = async (
   );
 
   const isInstalled = await adb.isAppInstalled(adbId, config.bundleId);
+  const appPath = getOptionalHarnessAppPath();
 
-  if (!isInstalled) {
-    const appPath = getHarnessAppPath();
+  if (isInstalled && appPath) {
+    await adb.uninstallApp(adbId, config.bundleId);
     await adb.installApp(adbId, appPath);
+  } else if (!isInstalled) {
+    const installPath = appPath ?? getHarnessAppPath();
+    await adb.installApp(adbId, installPath);
   }
 
   const appUid = await configureAndroidRuntime(adbId, config, harnessConfig);
 
+  if (permissionsEnabled) {
+    await adb.grantPermissions(adbId, config.bundleId);
+  }
+
   return {
     startApp: async (options) => {
       await adb.startApp(
@@ -315,6 +338,7 @@ export const getAndroidPhysicalDevicePlatformInstance = async (
 ): Promise<HarnessPlatformRunner> => {
   assertAndroidDevicePhysical(config.device);
   const detectNativeCrashes = harnessConfig.detectNativeCrashes ?? true;
+  const permissionsEnabled = harnessConfig.permissions ?? false;
 
   const adbId = await getAdbId(config.device);
 
@@ -333,6 +357,10 @@ export const getAndroidPhysicalDevicePlatformInstance = async (
 
   const appUid = await configureAndroidRuntime(adbId, config, harnessConfig);
 
+  if (permissionsEnabled) {
+    await adb.grantPermissions(adbId, config.bundleId);
+  }
+
   return {
     startApp: async (options) => {
       await adb.startApp(

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/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,
-    };
-};