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

package/src/__tests__/instance.test.ts

@@ -429,6 +429,60 @@ describe('Android platform instance', () => {
     fs.rmSync(appPath, { force: true });
   });
 
+  it('reinstalls the app from HARNESS_APP_PATH when already installed', async () => {
+    const appPath = path.join(os.tmpdir(), 'HarnessPlayground-installed.apk');
+    fs.writeFileSync(appPath, 'apk');
+    vi.stubEnv('HARNESS_APP_PATH', appPath);
+    vi.spyOn(
+      await import('../environment.js'),
+      'ensureAndroidEmulatorEnvironment',
+    ).mockResolvedValue('/tmp/android-sdk');
+    vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
+    vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
+    vi.spyOn(adb, 'waitForBoot').mockResolvedValue('emulator-5554');
+    vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(true);
+    const uninstallApp = vi
+      .spyOn(adb, 'uninstallApp')
+      .mockResolvedValue(undefined);
+    const installApp = vi.spyOn(adb, 'installApp').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
+      undefined,
+    );
+
+    await expect(
+      getAndroidEmulatorPlatformInstance(
+        {
+          name: 'android',
+          device: {
+            type: 'emulator',
+            name: 'Pixel_8_API_35',
+            avd: {
+              apiLevel: 35,
+              profile: 'pixel_8',
+              diskSize: '1G',
+              heapSize: '1G',
+            },
+          },
+          bundleId: 'com.harnessplayground',
+          activityName: '.MainActivity',
+        },
+        harnessConfig,
+        init,
+      ),
+    ).resolves.toBeDefined();
+
+    expect(uninstallApp).toHaveBeenCalledWith(
+      'emulator-5554',
+      'com.harnessplayground',
+    );
+    expect(installApp).toHaveBeenCalledWith('emulator-5554', appPath);
+
+    fs.rmSync(appPath, { force: true });
+  });
+
   it('throws a HarnessAppPathError when HARNESS_APP_PATH is missing', async () => {
     vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
     vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
@@ -607,4 +661,138 @@ describe('Android platform instance', () => {
     expect(appMonitor.addListener(listener)).toBeUndefined();
     expect(appMonitor.removeListener(listener)).toBeUndefined();
   });
+
+  it('grants permissions when permissions are enabled for emulator', async () => {
+    vi.spyOn(
+      await import('../environment.js'),
+      'ensureAndroidEmulatorEnvironment',
+    ).mockResolvedValue('/tmp/android-sdk');
+    vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
+    vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
+    vi.spyOn(adb, 'waitForBoot').mockResolvedValue('emulator-5554');
+    vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(true);
+    vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
+      undefined,
+    );
+    const grantPermissions = vi
+      .spyOn(adb, 'grantPermissions')
+      .mockResolvedValue(undefined);
+
+    const harnessConfigWithPermissions = {
+      ...harnessConfig,
+      permissions: true,
+    } as HarnessConfig;
+
+    await getAndroidEmulatorPlatformInstance(
+      {
+        name: 'android',
+        device: {
+          type: 'emulator',
+          name: 'Pixel_8_API_35',
+          avd: {
+            apiLevel: 35,
+            profile: 'pixel_8',
+            diskSize: '1G',
+            heapSize: '1G',
+          },
+        },
+        bundleId: 'com.harnessplayground',
+        activityName: '.MainActivity',
+      },
+      harnessConfigWithPermissions,
+      init,
+    );
+
+    expect(grantPermissions).toHaveBeenCalledWith(
+      'emulator-5554',
+      'com.harnessplayground',
+    );
+  });
+
+  it('does not grant permissions when permissions are disabled for emulator', async () => {
+    vi.spyOn(
+      await import('../environment.js'),
+      'ensureAndroidEmulatorEnvironment',
+    ).mockResolvedValue('/tmp/android-sdk');
+    vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
+    vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
+    vi.spyOn(adb, 'waitForBoot').mockResolvedValue('emulator-5554');
+    vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(true);
+    vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
+      undefined,
+    );
+    const grantPermissions = vi
+      .spyOn(adb, 'grantPermissions')
+      .mockResolvedValue(undefined);
+
+    await getAndroidEmulatorPlatformInstance(
+      {
+        name: 'android',
+        device: {
+          type: 'emulator',
+          name: 'Pixel_8_API_35',
+          avd: {
+            apiLevel: 35,
+            profile: 'pixel_8',
+            diskSize: '1G',
+            heapSize: '1G',
+          },
+        },
+        bundleId: 'com.harnessplayground',
+        activityName: '.MainActivity',
+      },
+      harnessConfig,
+      init,
+    );
+
+    expect(grantPermissions).not.toHaveBeenCalled();
+  });
+
+  it('grants permissions when permissions are enabled for physical device', async () => {
+    vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['012345']);
+    vi.spyOn(adb, 'getDeviceInfo').mockResolvedValue({
+      manufacturer: 'motorola',
+      model: 'moto g72',
+    });
+    vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(true);
+    vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
+      undefined,
+    );
+    const grantPermissions = vi
+      .spyOn(adb, 'grantPermissions')
+      .mockResolvedValue(undefined);
+
+    const harnessConfigWithPermissions = {
+      ...harnessConfig,
+      permissions: true,
+    } as HarnessConfig;
+
+    await getAndroidPhysicalDevicePlatformInstance(
+      {
+        name: 'android-device',
+        device: {
+          type: 'physical',
+          manufacturer: 'motorola',
+          model: 'moto g72',
+        },
+        bundleId: 'com.harnessplayground',
+        activityName: '.MainActivity',
+      },
+      harnessConfigWithPermissions,
+    );
+
+    expect(grantPermissions).toHaveBeenCalledWith(
+      '012345',
+      'com.harnessplayground',
+    );
+  });
 });

package/src/adb-errors.ts

@@ -0,0 +1,47 @@
+export class AdbError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'AdbError';
+  }
+}
+
+export class AdbDeviceNotFoundError extends AdbError {
+  constructor(adbId: string) {
+    super(
+      `Android device "${adbId}" not found or not connected. ` +
+      `Run "adb devices" to see available devices.`
+    );
+    this.name = 'AdbDeviceNotFoundError';
+  }
+}
+
+export class AdbAppNotInstalledError extends AdbError {
+  constructor(bundleId: string, adbId: string) {
+    super(
+      `App "${bundleId}" is not installed on device "${adbId}". ` +
+      `Install the app before running tests.`
+    );
+    this.name = 'AdbAppNotInstalledError';
+  }
+}
+
+export class AdbPermissionGrantError extends AdbError {
+  constructor(bundleId: string, permissions: string[], adbId: string) {
+    const permissionList = permissions.join(', ');
+    super(
+      `Failed to grant permissions [${permissionList}] to "${bundleId}" on device "${adbId}". ` +
+      `Verify the app is installed and the device supports these permissions.`
+    );
+    this.name = 'AdbPermissionGrantError';
+  }
+}
+
+export class AdbBinaryNotFoundError extends AdbError {
+  constructor() {
+    super(
+      `adb binary not found or not accessible. ` +
+      `Ensure Android SDK is properly installed and ANDROID_HOME is set.`
+    );
+    this.name = 'AdbBinaryNotFoundError';
+  }
+}

package/src/adb-id.ts

@@ -16,6 +16,10 @@ export const getAdbId = async (
 
   for (const adbId of adbIds) {
     if (isAndroidDeviceEmulator(device)) {
+      if (!isAdbIdEmulator(adbId)) {
+        continue;
+      }
+
       const emulatorName = await adb.getEmulatorName(adbId);
 
       if (emulatorName === device.name) {

package/src/adb.ts

@@ -1,5 +1,5 @@
 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';
@@ -23,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) => {
@@ -59,6 +63,7 @@ const waitWithSignal = async (
 
 const EMULATOR_STARTUP_OBSERVATION_TIMEOUT_MS = 5000;
 const EMULATOR_OUTPUT_BUFFER_LIMIT = 16 * 1024;
+const androidAdbLogger = logger.child('android-adb');
 
 export const emulatorProcess = {
   startDetachedProcess: (
@@ -374,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');
@@ -398,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);
@@ -730,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(