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

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 export { androidEmulator, physicalAndroidDevice, androidPlatform, } from './factory.js';
 export type { AndroidPlatformConfig } from './config.js';
+export { getNormalizedAvdCacheConfig, resolveAvdCachingEnabled, } from './avd-config.js';
+export { getHostAndroidSystemImageArch } from './environment.js';
+export { HarnessAppPathError, HarnessEmulatorConfigError } from './errors.js';
 export { getRunTargets } from './targets.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,qBAAqB,EACrB,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,EACL,2BAA2B,EAC3B,wBAAwB,GACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -1,2 +1,5 @@
 export { androidEmulator, physicalAndroidDevice, androidPlatform, } from './factory.js';
+export { getNormalizedAvdCacheConfig, resolveAvdCachingEnabled, } from './avd-config.js';
+export { getHostAndroidSystemImageArch } from './environment.js';
+export { HarnessAppPathError, HarnessEmulatorConfigError } from './errors.js';
 export { getRunTargets } from './targets.js';

package/dist/instance.d.ts

@@ -0,0 +1,6 @@
+import { type HarnessPlatformInitOptions, HarnessPlatformRunner } from '@react-native-harness/platforms';
+import type { Config as HarnessConfig } from '@react-native-harness/config';
+import { AndroidPlatformConfig } from './config.js';
+export declare const getAndroidEmulatorPlatformInstance: (config: AndroidPlatformConfig, harnessConfig: HarnessConfig, init: HarnessPlatformInitOptions) => Promise<HarnessPlatformRunner>;
+export declare const getAndroidPhysicalDevicePlatformInstance: (config: AndroidPlatformConfig, harnessConfig: HarnessConfig) => Promise<HarnessPlatformRunner>;
+//# sourceMappingURL=instance.d.ts.map

package/dist/instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../src/instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,0BAA0B,EAC/B,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE5E,OAAO,EACL,qBAAqB,EAGtB,MAAM,aAAa,CAAC;AAgKrB,eAAO,MAAM,kCAAkC,GAC7C,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,EAC5B,MAAM,0BAA0B,KAC/B,OAAO,CAAC,qBAAqB,CAoI/B,CAAC;AAEF,eAAO,MAAM,wCAAwC,GACnD,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,KAC3B,OAAO,CAAC,qBAAqB,CAiE/B,CAAC"}

package/dist/instance.js

@@ -0,0 +1,234 @@
+import { AppNotInstalledError, DeviceNotFoundError, } from '@react-native-harness/platforms';
+import { logger } from '@react-native-harness/tools';
+import { assertAndroidDeviceEmulator, assertAndroidDevicePhysical, } from './config.js';
+import { isAvdCompatible, readAvdConfig, resolveAvdCachingEnabled, } from './avd-config.js';
+import { getAdbId } from './adb-id.js';
+import * as adb from './adb.js';
+import { applyHarnessDebugHttpHost, clearHarnessDebugHttpHost, } from './shared-prefs.js';
+import { getDeviceName } from './utils.js';
+import { createAndroidAppMonitor } from './app-monitor.js';
+import { HarnessAppPathError, HarnessEmulatorConfigError } from './errors.js';
+import { ensureAndroidEmulatorEnvironment, getHostAndroidSystemImageArch, } from './environment.js';
+import { isInteractive } from '@react-native-harness/tools';
+import fs from 'node:fs';
+const androidInstanceLogger = logger.child('android-instance');
+const createNoopAppMonitor = () => ({
+    start: async () => undefined,
+    stop: async () => undefined,
+    dispose: async () => undefined,
+    addListener: () => undefined,
+    removeListener: () => undefined,
+});
+const getHarnessAppPath = () => {
+    const appPath = process.env.HARNESS_APP_PATH;
+    if (!appPath) {
+        throw new HarnessAppPathError('missing');
+    }
+    if (!fs.existsSync(appPath)) {
+        throw new HarnessAppPathError('invalid', appPath);
+    }
+    return appPath;
+};
+const configureAndroidRuntime = async (adbId, config, harnessConfig) => {
+    const metroPort = harnessConfig.metroPort;
+    await Promise.all([
+        adb.reversePort(adbId, metroPort),
+        adb.reversePort(adbId, 8080),
+        adb.setHideErrorDialogs(adbId, true),
+        applyHarnessDebugHttpHost(adbId, config.bundleId, `localhost:${metroPort}`),
+    ]);
+    return adb.getAppUid(adbId, config.bundleId);
+};
+const startAndWaitForBoot = async ({ emulatorName, signal, mode, }) => {
+    await adb.startEmulator(emulatorName, mode);
+    return adb.waitForBoot(emulatorName, signal);
+};
+const recreateAvd = async ({ emulatorConfig, }) => {
+    if (!emulatorConfig.avd) {
+        throw new HarnessEmulatorConfigError(emulatorConfig.name);
+    }
+    await adb.createAvd({
+        name: emulatorConfig.name,
+        apiLevel: emulatorConfig.avd.apiLevel,
+        profile: emulatorConfig.avd.profile,
+        diskSize: emulatorConfig.avd.diskSize,
+        heapSize: emulatorConfig.avd.heapSize,
+    });
+};
+const prepareCachedAvd = async ({ emulatorConfig, signal, }) => {
+    const emulatorName = emulatorConfig.name;
+    const hostArch = getHostAndroidSystemImageArch();
+    const hasExistingAvd = await adb.hasAvd(emulatorName);
+    const avdConfig = hasExistingAvd ? await readAvdConfig(emulatorName) : null;
+    const compatibility = avdConfig == null
+        ? { compatible: false, reason: 'Missing AVD config.ini.' }
+        : isAvdCompatible({
+            emulator: emulatorConfig,
+            avdConfig,
+            hostArch,
+        });
+    if (!hasExistingAvd || !compatibility.compatible) {
+        logger.info(hasExistingAvd
+            ? 'Recreating incompatible Android emulator %s...'
+            : 'Creating Android emulator %s...', emulatorName);
+        if (hasExistingAvd && !compatibility.compatible) {
+            androidInstanceLogger.debug('Android AVD %s is not reusable: %s', emulatorName, compatibility.reason);
+            await adb.deleteAvd(emulatorName);
+        }
+        await recreateAvd({ emulatorConfig });
+        const generationAdbId = await startAndWaitForBoot({
+            emulatorName,
+            signal,
+            mode: 'clean-snapshot-generation',
+        });
+        logger.info('Saving Android emulator snapshot for %s...', emulatorName);
+        await adb.stopEmulator(generationAdbId);
+        await adb.waitForEmulatorDisconnect(generationAdbId, signal);
+    }
+    else {
+        logger.info('Using cached Android emulator %s...', emulatorName);
+    }
+    return startAndWaitForBoot({
+        emulatorName,
+        signal,
+        mode: 'snapshot-reuse',
+    });
+};
+export const getAndroidEmulatorPlatformInstance = async (config, harnessConfig, init) => {
+    assertAndroidDeviceEmulator(config.device);
+    const detectNativeCrashes = harnessConfig.detectNativeCrashes ?? true;
+    const emulatorConfig = config.device;
+    const emulatorName = emulatorConfig.name;
+    const avdConfig = emulatorConfig.avd;
+    const avdCachingEnabled = resolveAvdCachingEnabled({
+        avd: avdConfig,
+        isInteractive: isInteractive(),
+    });
+    let adbId = await getAdbId(emulatorConfig);
+    let startedByHarness = false;
+    androidInstanceLogger.debug('resolved Android emulator %s with adb id %s', emulatorConfig.name, adbId ?? 'not-found');
+    if (!adbId) {
+        if (!avdConfig) {
+            throw new HarnessEmulatorConfigError(emulatorConfig.name);
+        }
+        await ensureAndroidEmulatorEnvironment(avdConfig.apiLevel);
+        adbId = avdCachingEnabled
+            ? await prepareCachedAvd({
+                emulatorConfig,
+                signal: init.signal,
+            })
+            : await (async () => {
+                if (!(await adb.hasAvd(emulatorConfig.name))) {
+                    logger.info('Creating Android emulator %s...', emulatorName);
+                    androidInstanceLogger.debug('creating Android AVD %s before startup', emulatorConfig.name);
+                    await recreateAvd({ emulatorConfig });
+                }
+                else {
+                    logger.info('Using existing Android emulator %s...', emulatorName);
+                }
+                androidInstanceLogger.debug('starting Android emulator %s', emulatorConfig.name);
+                return startAndWaitForBoot({
+                    emulatorName: emulatorConfig.name,
+                    signal: init.signal,
+                });
+            })();
+        startedByHarness = true;
+        androidInstanceLogger.debug('Android emulator %s connected as %s', emulatorConfig.name, adbId);
+    }
+    else if (emulatorConfig.avd) {
+        await ensureAndroidEmulatorEnvironment(emulatorConfig.avd.apiLevel);
+    }
+    if (!adbId) {
+        throw new DeviceNotFoundError(getDeviceName(emulatorConfig));
+    }
+    androidInstanceLogger.debug('waiting for Android emulator %s to finish booting', adbId);
+    const isInstalled = await adb.isAppInstalled(adbId, config.bundleId);
+    if (!isInstalled) {
+        const appPath = getHarnessAppPath();
+        await adb.installApp(adbId, appPath);
+    }
+    const appUid = await configureAndroidRuntime(adbId, config, harnessConfig);
+    return {
+        startApp: async (options) => {
+            await adb.startApp(adbId, config.bundleId, config.activityName, options ??
+                config.appLaunchOptions);
+        },
+        restartApp: async (options) => {
+            await adb.stopApp(adbId, config.bundleId);
+            await adb.startApp(adbId, config.bundleId, config.activityName, options ??
+                config.appLaunchOptions);
+        },
+        stopApp: async () => {
+            await adb.stopApp(adbId, config.bundleId);
+        },
+        dispose: async () => {
+            await adb.stopApp(adbId, config.bundleId);
+            await clearHarnessDebugHttpHost(adbId, config.bundleId);
+            await adb.setHideErrorDialogs(adbId, false);
+            if (startedByHarness) {
+                logger.info('Shutting down Android emulator %s...', emulatorName);
+                await adb.stopEmulator(adbId);
+            }
+        },
+        isAppRunning: async () => {
+            return await adb.isAppRunning(adbId, config.bundleId);
+        },
+        createAppMonitor: (options) => {
+            if (!detectNativeCrashes) {
+                return createNoopAppMonitor();
+            }
+            return createAndroidAppMonitor({
+                adbId,
+                bundleId: config.bundleId,
+                appUid,
+                crashArtifactWriter: options?.crashArtifactWriter,
+            });
+        },
+    };
+};
+export const getAndroidPhysicalDevicePlatformInstance = async (config, harnessConfig) => {
+    assertAndroidDevicePhysical(config.device);
+    const detectNativeCrashes = harnessConfig.detectNativeCrashes ?? true;
+    const adbId = await getAdbId(config.device);
+    if (!adbId) {
+        throw new DeviceNotFoundError(getDeviceName(config.device));
+    }
+    const isInstalled = await adb.isAppInstalled(adbId, config.bundleId);
+    if (!isInstalled) {
+        throw new AppNotInstalledError(config.bundleId, getDeviceName(config.device));
+    }
+    const appUid = await configureAndroidRuntime(adbId, config, harnessConfig);
+    return {
+        startApp: async (options) => {
+            await adb.startApp(adbId, config.bundleId, config.activityName, options ??
+                config.appLaunchOptions);
+        },
+        restartApp: async (options) => {
+            await adb.stopApp(adbId, config.bundleId);
+            await adb.startApp(adbId, config.bundleId, config.activityName, options ??
+                config.appLaunchOptions);
+        },
+        stopApp: async () => {
+            await adb.stopApp(adbId, config.bundleId);
+        },
+        dispose: async () => {
+            await adb.stopApp(adbId, config.bundleId);
+            await clearHarnessDebugHttpHost(adbId, config.bundleId);
+            await adb.setHideErrorDialogs(adbId, false);
+        },
+        isAppRunning: async () => {
+            return await adb.isAppRunning(adbId, config.bundleId);
+        },
+        createAppMonitor: (options) => {
+            if (!detectNativeCrashes) {
+                return createNoopAppMonitor();
+            }
+            return createAndroidAppMonitor({
+                adbId,
+                bundleId: config.bundleId,
+                appUid,
+                crashArtifactWriter: options?.crashArtifactWriter,
+            });
+        },
+    };
+};

package/dist/reader.d.ts

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

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

@@ -0,0 +1,57 @@
+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,
+    };
+};

package/dist/runner.d.ts

@@ -1,6 +1,6 @@
-import { HarnessPlatformRunner } from '@react-native-harness/platforms';
+import { HarnessPlatformRunner, type HarnessPlatformInitOptions } from '@react-native-harness/platforms';
 import type { Config as HarnessConfig } from '@react-native-harness/config';
 import { type AndroidPlatformConfig } from './config.js';
-declare const getAndroidRunner: (config: AndroidPlatformConfig, harnessConfig: HarnessConfig) => Promise<HarnessPlatformRunner>;
+declare const getAndroidRunner: (config: AndroidPlatformConfig, harnessConfig: HarnessConfig, init: HarnessPlatformInitOptions) => Promise<HarnessPlatformRunner>;
 export default getAndroidRunner;
 //# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAC;AAUrB,QAAA,MAAM,gBAAgB,GACpB,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,KAC3B,OAAO,CAAC,qBAAqB,CAmE/B,CAAC;AAEF,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,KAAK,0BAA0B,EAChC,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,EAEL,KAAK,qBAAqB,EAE3B,MAAM,aAAa,CAAC;AAWrB,QAAA,MAAM,gBAAgB,GACpB,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,EAC5B,MAAM,0BAA0B,KAC/B,OAAO,CAAC,qBAAqB,CAoB/B,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/runner.js

@@ -1,56 +1,16 @@
-import { DeviceNotFoundError, AppNotInstalledError, } from '@react-native-harness/platforms';
-import { AndroidPlatformConfigSchema, } from './config.js';
-import { getAdbId } from './adb-id.js';
-import * as adb from './adb.js';
-import { applyHarnessDebugHttpHost, clearHarnessDebugHttpHost, } from './shared-prefs.js';
-import { getDeviceName } from './utils.js';
-import { createAndroidAppMonitor } from './app-monitor.js';
-const getAndroidRunner = async (config, harnessConfig) => {
+import { AndroidPlatformConfigSchema, isAndroidDeviceEmulator, } from './config.js';
+import { getAndroidEmulatorPlatformInstance, getAndroidPhysicalDevicePlatformInstance, } from './instance.js';
+import { ensureAndroidEmulatorEnvironment, ensureAndroidPhysicalDeviceEnvironment, initializeAndroidProcessEnv, } from './environment.js';
+const getAndroidRunner = async (config, harnessConfig, init) => {
     const parsedConfig = AndroidPlatformConfigSchema.parse(config);
-    const adbId = await getAdbId(parsedConfig.device);
-    if (!adbId) {
-        throw new DeviceNotFoundError(getDeviceName(parsedConfig.device));
+    initializeAndroidProcessEnv();
+    if (isAndroidDeviceEmulator(parsedConfig.device)) {
+        if (parsedConfig.device.avd) {
+            await ensureAndroidEmulatorEnvironment(parsedConfig.device.avd.apiLevel);
+        }
+        return getAndroidEmulatorPlatformInstance(parsedConfig, harnessConfig, init);
     }
-    const isInstalled = await adb.isAppInstalled(adbId, parsedConfig.bundleId);
-    if (!isInstalled) {
-        throw new AppNotInstalledError(parsedConfig.bundleId, getDeviceName(parsedConfig.device));
-    }
-    const metroPort = harnessConfig.metroPort;
-    await Promise.all([
-        adb.reversePort(adbId, metroPort),
-        adb.reversePort(adbId, 8080),
-        adb.reversePort(adbId, harnessConfig.webSocketPort),
-        adb.setHideErrorDialogs(adbId, true),
-        applyHarnessDebugHttpHost(adbId, parsedConfig.bundleId, `localhost:${metroPort}`),
-    ]);
-    const appUid = await adb.getAppUid(adbId, parsedConfig.bundleId);
-    return {
-        startApp: async (options) => {
-            await adb.startApp(adbId, parsedConfig.bundleId, parsedConfig.activityName, options ??
-                parsedConfig.appLaunchOptions);
-        },
-        restartApp: async (options) => {
-            await adb.stopApp(adbId, parsedConfig.bundleId);
-            await adb.startApp(adbId, parsedConfig.bundleId, parsedConfig.activityName, options ??
-                parsedConfig.appLaunchOptions);
-        },
-        stopApp: async () => {
-            await adb.stopApp(adbId, parsedConfig.bundleId);
-        },
-        dispose: async () => {
-            await adb.stopApp(adbId, parsedConfig.bundleId);
-            await clearHarnessDebugHttpHost(adbId, parsedConfig.bundleId);
-            await adb.setHideErrorDialogs(adbId, false);
-        },
-        isAppRunning: async () => {
-            return await adb.isAppRunning(adbId, parsedConfig.bundleId);
-        },
-        createAppMonitor: (options) => createAndroidAppMonitor({
-            adbId,
-            bundleId: parsedConfig.bundleId,
-            appUid,
-            crashArtifactWriter: options?.crashArtifactWriter,
-        }),
-    };
+    await ensureAndroidPhysicalDeviceEnvironment();
+    return getAndroidPhysicalDevicePlatformInstance(parsedConfig, harnessConfig);
 };
 export default getAndroidRunner;

package/dist/targets.d.ts

@@ -1,3 +1,3 @@
-import { RunTarget } from "@react-native-harness/platforms";
+import { RunTarget } from '@react-native-harness/platforms';
 export declare const getRunTargets: () => Promise<RunTarget[]>;
 //# sourceMappingURL=targets.d.ts.map

package/dist/targets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../src/targets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAG5D,eAAO,MAAM,aAAa,QAAa,OAAO,CAAC,SAAS,EAAE,CAkCzD,CAAC"}
+{"version":3,"file":"targets.d.ts","sourceRoot":"","sources":["../src/targets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAI5D,eAAO,MAAM,aAAa,QAAa,OAAO,CAAC,SAAS,EAAE,CAoCzD,CAAC"}

package/dist/targets.js

@@ -1,5 +1,7 @@
 import * as adb from './adb.js';
+import { ensureAndroidDiscoveryEnvironment } from './environment.js';
 export const getRunTargets = async () => {
+    await ensureAndroidDiscoveryEnvironment();
     const [avds, connectedDevices] = await Promise.all([
         adb.getAvds(),
         adb.getConnectedDevices(),