@react-native-harness/platform-android 1.0.0-canary.1761729829908

package/src/adb-id.ts

@@ -0,0 +1,36 @@
+import * as adb from './adb.js';
+import {
+  isAndroidDeviceEmulator,
+  isAndroidDevicePhysical,
+  AndroidDevice,
+} from './config.js';
+
+export const isAdbIdEmulator = (adbId: string): boolean => {
+  return adbId.startsWith('emulator-');
+};
+
+export const getAdbId = async (
+  device: AndroidDevice
+): Promise<string | null> => {
+  const adbIds = await adb.getDeviceIds();
+
+  for (const adbId of adbIds) {
+    if (isAndroidDeviceEmulator(device)) {
+      const emulatorName = await adb.getEmulatorName(adbId);
+
+      if (emulatorName === device.name) {
+        return adbId;
+      }
+    } else if (isAndroidDevicePhysical(device)) {
+      const deviceInfo = await adb.getDeviceInfo(adbId);
+      if (
+        deviceInfo?.manufacturer === device.manufacturer &&
+        deviceInfo?.model === device.model
+      ) {
+        return adbId;
+      }
+    }
+  }
+
+  return null;
+};

package/src/adb.ts

@@ -0,0 +1,99 @@
+import { spawn } from '@react-native-harness/tools';
+
+export const isAppInstalled = async (
+  adbId: string,
+  bundleId: string
+): Promise<boolean> => {
+  const { stdout } = await spawn('adb', [
+    '-s',
+    adbId,
+    'shell',
+    'pm',
+    'list',
+    'packages',
+    bundleId,
+  ]);
+  return stdout.trim() !== '';
+};
+
+export const reversePort = async (
+  adbId: string,
+  port: number
+): Promise<void> => {
+  await spawn('adb', ['-s', adbId, 'reverse', `tcp:${port}`, `tcp:${port}`]);
+};
+
+export const stopApp = async (
+  adbId: string,
+  bundleId: string
+): Promise<void> => {
+  await spawn('adb', ['-s', adbId, 'shell', 'am', 'force-stop', bundleId]);
+};
+
+export const startApp = async (
+  adbId: string,
+  bundleId: string,
+  activityName: string
+): Promise<void> => {
+  await spawn('adb', [
+    '-s',
+    adbId,
+    'shell',
+    'am',
+    'start',
+    '-n',
+    `${bundleId}/${activityName}`,
+  ]);
+};
+
+export const getDeviceIds = async (): Promise<string[]> => {
+  const { stdout } = await spawn('adb', ['devices']);
+  return stdout
+    .split('\n')
+    .slice(1) // Skip header
+    .filter((line) => line.trim() !== '')
+    .map((line) => line.split('\t')[0]);
+};
+
+export const getEmulatorName = async (
+  adbId: string
+): Promise<string | null> => {
+  const { stdout } = await spawn('adb', ['-s', adbId, 'emu', 'avd', 'name']);
+  return stdout.split('\n')[0].trim() || null;
+};
+
+export const getShellProperty = async (
+  adbId: string,
+  property: string
+): Promise<string | null> => {
+  const { stdout } = await spawn('adb', [
+    '-s',
+    adbId,
+    'shell',
+    'getprop',
+    property,
+  ]);
+  return stdout.trim() || null;
+};
+
+export type DeviceInfo = {
+  manufacturer: string | null;
+  model: string | null;
+};
+
+export const getDeviceInfo = async (
+  adbId: string
+): Promise<DeviceInfo | null> => {
+  const manufacturer = await getShellProperty(adbId, 'ro.product.manufacturer');
+  const model = await getShellProperty(adbId, 'ro.product.model');
+  return { manufacturer, model };
+};
+
+export const isBootCompleted = async (adbId: string): Promise<boolean> => {
+  const bootCompleted = await getShellProperty(adbId, 'sys.boot_completed');
+  return bootCompleted === '1';
+};
+
+export const stopEmulator = async (adbId: string): Promise<void> => {
+  await spawn('adb', ['-s', adbId, 'emu', 'kill']);
+};

package/src/config.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+
+export const AndroidEmulatorSchema = z.object({
+  type: z.literal('emulator'),
+  name: z.string().min(1, 'Name is required'),
+});
+
+export const PhysicalAndroidDeviceSchema = z.object({
+  type: z.literal('physical'),
+  manufacturer: z.string().min(1, 'Manufacturer is required'),
+  model: z.string().min(1, 'Model is required'),
+});
+
+export const AndroidDeviceSchema = z.discriminatedUnion('type', [
+  AndroidEmulatorSchema,
+  PhysicalAndroidDeviceSchema,
+]);
+
+export const AndroidPlatformConfigSchema = z.object({
+  name: z.string().min(1, 'Name is required'),
+  device: AndroidDeviceSchema,
+  bundleId: z.string().min(1, 'Bundle ID is required'),
+  activityName: z
+    .string()
+    .min(1, 'Activity name is required')
+    .default('.MainActivity'),
+});
+
+export type AndroidEmulator = z.infer<typeof AndroidEmulatorSchema>;
+export type PhysicalAndroidDevice = z.infer<typeof PhysicalAndroidDeviceSchema>;
+export type AndroidDevice = z.infer<typeof AndroidDeviceSchema>;
+export type AndroidPlatformConfig = z.infer<typeof AndroidPlatformConfigSchema>;
+
+export const isAndroidDeviceEmulator = (
+  device: AndroidDevice
+): device is AndroidEmulator => {
+  return device.type === 'emulator';
+};
+
+export const isAndroidDevicePhysical = (
+  device: AndroidDevice
+): device is PhysicalAndroidDevice => {
+  return device.type === 'physical';
+};
+
+export function assertAndroidDeviceEmulator(
+  device: AndroidDevice
+): asserts device is AndroidEmulator {
+  if (!isAndroidDeviceEmulator(device)) {
+    throw new Error('Device is not an emulator');
+  }
+}
+
+export function assertAndroidDevicePhysical(
+  device: AndroidDevice
+): asserts device is PhysicalAndroidDevice {
+  if (!isAndroidDevicePhysical(device)) {
+    throw new Error('Device is not a physical device');
+  }
+}

package/src/emulator.ts

@@ -0,0 +1,41 @@
+import { spawn } from '@react-native-harness/tools';
+import * as adb from './adb.js';
+
+export type AndroidEmulator = {
+  adbId: string;
+  stop: () => Promise<void>;
+};
+
+export const runEmulator = async (
+  avdName: string
+): Promise<AndroidEmulator> => {
+  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 (): Promise<void> => {
+    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/src/factory.ts

@@ -0,0 +1,85 @@
+import {
+  DeviceNotFoundError,
+  AppNotInstalledError,
+  HarnessPlatform,
+} from '@react-native-harness/platforms';
+import {
+  AndroidPlatformConfigSchema,
+  isAndroidDevicePhysical,
+  type AndroidEmulator,
+  type AndroidPlatformConfig,
+  type PhysicalAndroidDevice,
+} from './config.js';
+import { getAdbId } from './adb-id.js';
+import * as adb from './adb.js';
+import { getDeviceName } from './utils.js';
+
+export const androidEmulator = (name: string): AndroidEmulator => ({
+  type: 'emulator',
+  name,
+});
+
+export const physicalAndroidDevice = (
+  manufacturer: string,
+  model: string
+): PhysicalAndroidDevice => ({
+  type: 'physical',
+  manufacturer: manufacturer.toLowerCase(),
+  model: model.toLowerCase(),
+});
+
+export const androidPlatform = (
+  config: AndroidPlatformConfig
+): HarnessPlatform => ({
+  name: config.name,
+  getInstance: async () => {
+    const parsedConfig = AndroidPlatformConfigSchema.parse(config);
+    const adbId = await getAdbId(parsedConfig.device);
+
+    if (!adbId) {
+      throw new DeviceNotFoundError(getDeviceName(parsedConfig.device));
+    }
+
+    const isInstalled = await adb.isAppInstalled(adbId, parsedConfig.bundleId);
+
+    if (!isInstalled) {
+      throw new AppNotInstalledError(
+        parsedConfig.bundleId,
+        getDeviceName(parsedConfig.device)
+      );
+    }
+
+    if (isAndroidDevicePhysical(parsedConfig.device)) {
+      // Reverse ports to allow the app to load from a local machine.
+      await Promise.all([
+        adb.reversePort(adbId, 8081),
+        adb.reversePort(adbId, 8080),
+        adb.reversePort(adbId, 3001),
+      ]);
+    }
+
+    return {
+      startApp: async () => {
+        await adb.startApp(
+          adbId,
+          parsedConfig.bundleId,
+          parsedConfig.activityName
+        );
+      },
+      restartApp: async () => {
+        await adb.stopApp(adbId, parsedConfig.bundleId);
+        await adb.startApp(
+          adbId,
+          parsedConfig.bundleId,
+          parsedConfig.activityName
+        );
+      },
+      stopApp: async () => {
+        await adb.stopApp(adbId, parsedConfig.bundleId);
+      },
+      dispose: async () => {
+        await adb.stopApp(adbId, parsedConfig.bundleId);
+      },
+    };
+  },
+});

package/src/index.ts

@@ -0,0 +1,6 @@
+export {
+  androidEmulator,
+  physicalAndroidDevice,
+  androidPlatform,
+} from './factory.js';
+export type { AndroidPlatformConfig } from './config.js';

package/src/utils.ts

@@ -0,0 +1,9 @@
+import { isAndroidDeviceEmulator, type AndroidDevice } from './config.js';
+
+export const getDeviceName = (device: AndroidDevice): string => {
+  if (isAndroidDeviceEmulator(device)) {
+    return `${device.name} (emulator)`;
+  }
+
+  return `${device.manufacturer} ${device.model}`;
+};

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "../tools"
+    },
+    {
+      "path": "../platforms"
+    },
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,21 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "rootDir": "src",
+    "outDir": "dist",
+    "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
+    "emitDeclarationOnly": false,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "references": [
+    {
+      "path": "../tools/tsconfig.lib.json"
+    },
+    {
+      "path": "../platforms/tsconfig.lib.json"
+    }
+  ]
+}