detox 20.12.0-smoke.0 → 20.12.0-smoke.1

package/src/DetoxWorker.js

@@ -59,7 +59,6 @@ class DetoxWorker {
     /** @type {Detox.WebFacade} */
     this.web = null;
 
-    this._deviceAllocator = null;
     this._deviceCookie = null;
 
     this.trace = this._context.trace;
@@ -207,7 +206,6 @@ class DetoxWorker {
       await this._context[symbols.deallocateDevice](this._deviceCookie);
     }
 
-    this._deviceAllocator = null;
     this._deviceCookie = null;
     this.device = null;
   }

package/src/android/core/NativeElement.js

@@ -15,39 +15,37 @@ class NativeElement {
   constructor(invocationManager, emitter, matcher) {
     this._invocationManager = invocationManager;
     this._emitter = emitter;
-    this._originalMatcher = matcher;
-    this._selectElementWithMatcher(this._originalMatcher);
+    this._matcher = matcher;
   }
 
-  _selectElementWithMatcher(matcher) {
-    this._call = invoke.call(invoke.Espresso, 'onView', matcher._call);
+  get _call() {
+    return invoke.call(invoke.Espresso, 'onView', this._matcher._call);
   }
 
   atIndex(index) {
     if (typeof index !== 'number') throw new DetoxRuntimeError({ message: `Element atIndex argument must be a number, got ${typeof index}` });
-    const matcher = this._originalMatcher;
-    this._originalMatcher._call = invoke.callDirectly(DetoxMatcherApi.matcherForAtIndex(index, matcher._call.value));
+    const matcher = this._matcher;
+    this._matcher._call = invoke.callDirectly(DetoxMatcherApi.matcherForAtIndex(index, matcher._call.value));
 
-    this._selectElementWithMatcher(this._originalMatcher);
     return this;
   }
 
   async tap(value) {
     const action = new actions.TapAction(value);
     const traceDescription = actionDescription.tapAtPoint(value);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async tapAtPoint(value) {
     const action = new actions.TapAtPointAction(value);
     const traceDescription = actionDescription.tapAtPoint(value);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async longPress() {
     const action = new actions.LongPressAction();
     const traceDescription = actionDescription.longPress();
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async multiTap(times) {
@@ -56,61 +54,61 @@ class NativeElement {
 
     const action = new actions.MultiClickAction(times);
     const traceDescription = actionDescription.multiTap(times);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async tapBackspaceKey() {
     const action = new actions.PressKeyAction(67);
     const traceDescription = actionDescription.tapBackspaceKey();
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async tapReturnKey() {
     const action = new actions.TypeTextAction('\n');
     const traceDescription = actionDescription.tapReturnKey();
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async typeText(value) {
     const action = new actions.TypeTextAction(value);
     const traceDescription = actionDescription.typeText(value);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async replaceText(value) {
     const action = new actions.ReplaceTextAction(value);
     const traceDescription = actionDescription.replaceText(value);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async clearText() {
     const action = new actions.ClearTextAction();
     const traceDescription = actionDescription.clearText();
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async scroll(amount, direction = 'down', startPositionX, startPositionY) {
     const action = new actions.ScrollAmountAction(direction, amount, startPositionX, startPositionY);
     const traceDescription = actionDescription.scroll(amount, direction, startPositionX, startPositionY);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async scrollTo(edge) {
     // override the user's element selection with an extended matcher that looks for UIScrollView children
-    this._selectElementWithMatcher(this._originalMatcher._extendToDescendantScrollViews());
+    this._matcher = this._matcher._extendToDescendantScrollViews();
 
     const action = new actions.ScrollEdgeAction(edge);
     const traceDescription = actionDescription.scrollTo(edge);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async scrollToIndex(index) {
     // override the user's element selection with an extended matcher that looks for UIScrollView children
-    this._selectElementWithMatcher(this._originalMatcher._extendToDescendantScrollViews());
+    this._matcher = this._matcher._extendToDescendantScrollViews();
 
     const action = new actions.ScrollToIndex(index);
     const traceDescription = actionDescription.scrollToIndex(index);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async setDatePickerDate(rawDateString, formatString) {
@@ -120,7 +118,7 @@ class NativeElement {
 
     const action = new actions.SetDatePickerDateAction(dateString, formatString);
     const traceDescription = actionDescription.setDatePickerDate(dateString, formatString);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   /**
@@ -134,18 +132,18 @@ class NativeElement {
     normalizedSwipeOffset = Number.isNaN(normalizedSwipeOffset) ? 0.75 : normalizedSwipeOffset;
 
     // override the user's element selection with an extended matcher that avoids RN issues with RCTScrollView
-    this._selectElementWithMatcher(this._originalMatcher._avoidProblematicReactNativeElements());
+    this._matcher = this._matcher._avoidProblematicReactNativeElements();
 
     const action = new actions.SwipeAction(direction, speed, normalizedSwipeOffset, normalizedStartingPointX, normalizedStartingPointY);
     const traceDescription = actionDescription.swipe(direction, speed, normalizedSwipeOffset, normalizedStartingPointX, normalizedStartingPointY);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async takeScreenshot(screenshotName) {
     // TODO this should be moved to a lower-layer handler of this use-case
     const action = new actions.TakeElementScreenshot();
     const traceDescription = actionDescription.takeScreenshot(screenshotName);
-    const resultBase64 = await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    const resultBase64 = await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
     const filePath = tempfile('detox.element-screenshot.png');
     await fs.writeFile(filePath, resultBase64, 'base64');
 
@@ -160,19 +158,18 @@ class NativeElement {
   async getAttributes() {
     const action = new actions.GetAttributes();
     const traceDescription = actionDescription.getAttributes();
-    const result = await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
-    return JSON.parse(result);
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async adjustSliderToPosition(newPosition) {
     const action = new actions.AdjustSliderToPosition(newPosition);
     const traceDescription = actionDescription.adjustSliderToPosition(newPosition);
-    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, action, traceDescription).execute();
   }
 
   async performAccessibilityAction(actionName) {
     const traceDescription = actionDescription.performAccessibilityAction(actionName);
-    return await new ActionInteraction(this._invocationManager, this, new actions.AccessibilityActionAction(actionName), traceDescription).execute();
+    return await new ActionInteraction(this._invocationManager, this._matcher, new actions.AccessibilityActionAction(actionName), traceDescription).execute();
   }
 }
 

package/src/android/espressoapi/DetoxAssertion.js

@@ -14,7 +14,7 @@ function sanitize_matcher(matcher) {
   return originalMatcher.type ? originalMatcher.value : originalMatcher;
 } 
 class DetoxAssertion {
-  static assertMatcher(i, m) {
+  static assertMatcher(viewInteraction, viewMatcher) {
     return {
       target: {
         type: "Class",
@@ -23,15 +23,15 @@ class DetoxAssertion {
       method: "assertMatcher",
       args: [{
         type: "Invocation",
-        value: i
+        value: viewInteraction
       }, {
         type: "Invocation",
-        value: sanitize_matcher(m)
+        value: sanitize_matcher(viewMatcher)
       }]
     };
   }
 
-  static assertNotVisible(i) {
+  static assertNotVisible(viewInteraction) {
     return {
       target: {
         type: "Class",
@@ -40,12 +40,12 @@ class DetoxAssertion {
       method: "assertNotVisible",
       args: [{
         type: "Invocation",
-        value: i
+        value: viewInteraction
       }]
     };
   }
 
-  static assertNotExists(i) {
+  static assertNotExists(viewInteraction) {
     return {
       target: {
         type: "Class",
@@ -54,12 +54,12 @@ class DetoxAssertion {
       method: "assertNotExists",
       args: [{
         type: "Invocation",
-        value: i
+        value: viewInteraction
       }]
     };
   }
 
-  static waitForAssertMatcher(i, m, timeoutSeconds) {
+  static waitForAssertMatcher(viewInteraction, viewMatcher, timeoutSeconds) {
     if (typeof timeoutSeconds !== "number") throw new Error("timeoutSeconds should be a number, but got " + (timeoutSeconds + (" (" + (typeof timeoutSeconds + ")"))));
     return {
       target: {
@@ -69,10 +69,10 @@ class DetoxAssertion {
       method: "waitForAssertMatcher",
       args: [{
         type: "Invocation",
-        value: i
+        value: viewInteraction
       }, {
         type: "Invocation",
-        value: sanitize_matcher(m)
+        value: sanitize_matcher(viewMatcher)
       }, {
         type: "Double",
         value: timeoutSeconds
@@ -80,7 +80,8 @@ class DetoxAssertion {
     };
   }
 
-  static waitForAssertMatcherWithSearchAction(i, vm, searchAction, searchMatcher) {
+  static waitForAssertMatcherWithSearchAction(viewInteraction, viewMatcher, searchAction, searchMatcher
+  ) {
     return {
       target: {
         type: "Class",
@@ -89,13 +90,14 @@ class DetoxAssertion {
       method: "waitForAssertMatcherWithSearchAction",
       args: [{
         type: "Invocation",
-        value: i
+        value: viewInteraction
       }, {
         type: "Invocation",
-        value: sanitize_matcher(vm)
+        value: sanitize_matcher(viewMatcher)
       }, searchAction, {
         type: "Invocation",
-        value: sanitize_matcher(searchMatcher)
+        value: sanitize_matcher(searchMatcher
+        )
       }]
     };
   }

package/src/android/espressoapi/EspressoDetox.js

@@ -5,9 +5,16 @@
 */
 
 
+function sanitize_matcher(matcher) {
+  if (!matcher._call) {
+    return matcher;
+  }
 
+  const originalMatcher = typeof matcher._call === 'function' ? matcher._call() : matcher._call;
+  return originalMatcher.type ? originalMatcher.value : originalMatcher;
+} 
 class EspressoDetox {
-  static perform(interaction, action) {
+  static perform(matcher, action) {
     return {
       target: {
         type: "Class",
@@ -16,7 +23,7 @@ class EspressoDetox {
       method: "perform",
       args: [{
         type: "Invocation",
-        value: interaction
+        value: sanitize_matcher(matcher)
       }, action]
     };
   }

package/src/android/interactions/native.js

@@ -25,9 +25,9 @@ class Interaction {
 }
 
 class ActionInteraction extends Interaction {
-  constructor(invocationManager, element, action, traceDescription) {
+  constructor(invocationManager, matcher, action, traceDescription) {
     super(invocationManager, traceDescription);
-    this._call = EspressoDetoxApi.perform(call(element._call), action._call);
+    this._call = EspressoDetoxApi.perform(matcher, action._call);
     // TODO: move this.execute() here from the caller
   }
 }
@@ -48,7 +48,6 @@ class WaitForInteraction extends Interaction {
     super(invocationManager, expectTraceDescription);
     this._element = element;
     this._assertionMatcher = assertionMatcher;
-    this._element._selectElementWithMatcher(this._element._originalMatcher);
   }
 
   async withTimeout(timeout) {

package/src/configuration/composeLoggerConfig.js

@@ -32,6 +32,7 @@ function composeLoggerConfig(opts) {
       if (!config) return acc;
       const { options } = config;
       return _.merge(acc, {
+        // @ts-ignore-line
         options: typeof options === 'function' ? options(acc) : options
       });
     },

package/src/devices/allocation/DeviceAllocator.js

@@ -1,13 +1,20 @@
-// @ts-nocheck
+/**
+ * @typedef {import('./drivers/AllocationDriverBase').AllocationDriverBase} AllocationDriverBase
+ * @typedef {import('./drivers/AllocationDriverBase').DeallocOptions} DeallocOptions
+ * @typedef {import('../common/drivers/DeviceCookie').DeviceCookie} DeviceCookie
+ */
+
 const log = require('../../utils/logger').child({ cat: 'device,device-allocation' });
 const traceMethods = require('../../utils/traceMethods');
 
 class DeviceAllocator {
   /**
-   * @param allocationDriver { AllocationDriverBase }
+   * @param {AllocationDriverBase} allocationDriver
    */
   constructor(allocationDriver) {
     this._driver = allocationDriver;
+    this._counter = 0;
+    this._ids = new Map();
     traceMethods(log, this, ['init', 'cleanup', 'emergencyCleanup']);
   }
 
@@ -21,38 +28,42 @@ class DeviceAllocator {
   }
 
   /**
-   * @param deviceConfig { Object }
+   * @param {Detox.DetoxDeviceConfig} deviceConfig
    * @returns {Promise<DeviceCookie>}
    */
   async allocate(deviceConfig) {
-    return await log.trace.complete({ data: deviceConfig, id: Math.random() }, 'allocate', async () => {
+    const tid = this._counter++;
+    return await log.trace.complete({ data: deviceConfig, id: tid }, 'allocate', async () => {
       const cookie = await this._driver.allocate(deviceConfig);
-      log.debug({ event: undefined }, `settled on ${cookie}`);
+      log.debug({ data: cookie }, `settled on ${cookie.name || cookie.id}`);
+      this._ids.set(cookie.id, tid);
       return cookie;
     });
   }
 
   /**
-   * @param {DeviceCookie} deviceCookie
+   * @param {DeviceCookie} cookie
    * @returns {Promise<DeviceCookie>}
    */
-  async postAllocate(deviceCookie) {
-    return await log.trace.complete({ data: deviceCookie, id: Math.random() }, `post-allocate: ${deviceCookie}`, async () => {
+  async postAllocate(cookie) {
+    const tid = this._ids.get(cookie.id);
+    return await log.trace.complete({ data: cookie, id: tid }, `post-allocate: ${cookie.id}`, async () => {
       const updatedCookie = typeof this._driver.postAllocate === 'function'
-        ? await this._driver.postAllocate(deviceCookie)
+        ? await this._driver.postAllocate(cookie)
         : undefined;
 
-      return updatedCookie || deviceCookie;
+      return updatedCookie || cookie;
     });
   }
 
   /**
-   * @param cookie { DeviceCookie }
-   * @param options { Partial<DeallocOptions> }
+   * @param {DeviceCookie} cookie
+   * @param {DeallocOptions} options
    * @returns {Promise<void>}
    */
   async free(cookie, options = {}) {
-    await log.trace.complete({ data: options, id: Math.random() }, `free: ${cookie}`, async () => {
+    const tid = this._ids.get(cookie.id);
+    await log.trace.complete({ data: options, id: tid }, `free: ${cookie.id}`, async () => {
       await this._driver.free(cookie, options);
     });
   }

package/src/devices/allocation/DeviceRegistry.js

@@ -127,6 +127,9 @@ class DeviceRegistry {
     });
   }
 
+  /**
+   * @returns {Promise<DeviceList>}
+   */
   async readSessionDevices() {
     let devices;
     await this._lockfile.exclusively(() => {

package/src/devices/allocation/drivers/AllocationDriverBase.d.ts

@@ -0,0 +1,15 @@
+/* eslint-disable import/no-unresolved,node/no-missing-import,node/no-unsupported-features/es-syntax */
+import { DeviceCookie } from '../../common/drivers/DeviceCookie';
+
+export interface DeallocOptions {
+  shutdown?: boolean;
+}
+
+export interface AllocationDriverBase {
+  init?(): Promise<void>;
+  allocate(deviceConfig: any): Promise<DeviceCookie>;
+  postAllocate?(deviceCookie: DeviceCookie): Promise<DeviceCookie | void>;
+  free(cookie: DeviceCookie, options: DeallocOptions): Promise<void>;
+  cleanup?(): Promise<void>;
+  emergencyCleanup?(): void;
+}

package/src/devices/allocation/drivers/android/attached/AttachedAndroidAllocDriver.js

@@ -1,15 +1,19 @@
-// @ts-nocheck
-const AttachedAndroidDeviceCookie = require('../../../../cookies/AttachedAndroidDeviceCookie');
-const AllocationDriverBase = require('../../AllocationDriverBase');
-
-class AttachedAndroidAllocDriver extends AllocationDriverBase {
+/**
+ * @typedef {import('../../AllocationDriverBase').AllocationDriverBase} AllocationDriverBase
+ * @typedef {import('../../../../common/drivers/android/cookies').AndroidDeviceCookie} AndroidDeviceCookie
+ */
+
+/**
+ * @implements {AllocationDriverBase}
+ */
+class AttachedAndroidAllocDriver {
   /**
-   * @param adb { ADB }
-   * @param deviceRegistry { DeviceRegistry }
-   * @param freeDeviceFinder { FreeDeviceFinder }
+   * @param {object} options
+   * @param {import('../../../../common/drivers/android/exec/ADB')} options.adb
+   * @param {import('../../../DeviceRegistry')} options.deviceRegistry
+   * @param {import('../FreeDeviceFinder')} options.freeDeviceFinder
    */
   constructor({ adb, deviceRegistry, freeDeviceFinder }) {
-    super();
     this._adb = adb;
     this._deviceRegistry = deviceRegistry;
     this._freeDeviceFinder = freeDeviceFinder;
@@ -27,11 +31,11 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
     const adbNamePattern = deviceConfig.device.adbName;
     const adbName = await this._deviceRegistry.registerDevice(() => this._freeDeviceFinder.findFreeDevice(adbNamePattern));
 
-    return new AttachedAndroidDeviceCookie(adbName);
+    return { id: adbName, adbName };
   }
 
   /**
-   * @param {AttachedAndroidDeviceCookie} deviceCookie
+   * @param {AndroidDeviceCookie} deviceCookie
    * @returns {Promise<void>}
    */
   async postAllocate(deviceCookie) {
@@ -43,7 +47,7 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
   }
 
   /**
-   * @param cookie { AttachedAndroidDeviceCookie }
+   * @param cookie { AndroidDeviceCookie }
    * @return {Promise<void>}
    */
   async free(cookie) {

package/src/devices/allocation/drivers/android/emulator/EmulatorAllocDriver.js

@@ -1,13 +1,19 @@
+/**
+ * @typedef {import('../../AllocationDriverBase').AllocationDriverBase} AllocationDriverBase
+ * @typedef {import('../../../../common/drivers/android/cookies').AndroidDeviceCookie} AndroidDeviceCookie
+ */
+
 const _ = require('lodash');
 
 const Deferred = require('../../../../../utils/Deferred');
 const log = require('../../../../../utils/logger').child({ cat: 'device,device-allocation' });
-const AndroidEmulatorCookie = require('../../../../cookies/AndroidEmulatorCookie');
-const AllocationDriverBase = require('../../AllocationDriverBase');
 
 const { patchAvdSkinConfig } = require('./patchAvdSkinConfig');
 
-class EmulatorAllocDriver extends AllocationDriverBase {
+/**
+ * @implements {AllocationDriverBase}
+ */
+class EmulatorAllocDriver {
   /**
    * @param {object} options
    * @param {import('../../../../common/drivers/android/exec/ADB')} options.adb
@@ -29,13 +35,6 @@ class EmulatorAllocDriver extends AllocationDriverBase {
     emulatorVersionResolver,
     emulatorLauncher
   }) {
-    super();
-
-    /** @type {Deferred} */
-    this._deferredAllocation = Deferred.resolved(null);
-    /** @type {Promise<unknown>} */
-    this._pendingAllocation = Promise.resolve();
-
     this._adb = adb;
     this._avdValidator = avdValidator;
     this._deviceRegistry = deviceRegistry;
@@ -44,6 +43,7 @@ class EmulatorAllocDriver extends AllocationDriverBase {
     this._freeDeviceFinder = freeDeviceFinder;
     this._freePortFinder = freePortFinder;
     this._shouldShutdown = detoxConfig.behavior.cleanup.shutdownDevice;
+    this._fixAvdConfigIniSkinNameIfNeeded = _.memoize(this._fixAvdConfigIniSkinNameIfNeeded.bind(this));
   }
 
   async init() {
@@ -52,68 +52,45 @@ class EmulatorAllocDriver extends AllocationDriverBase {
 
   /**
    * @param deviceConfig
-   * @returns {Promise<AndroidEmulatorCookie>}
+   * @returns {Promise<AndroidDeviceCookie>}
    */
   async allocate(deviceConfig) {
-    await this._pendingAllocation.catch(() => { /* ignore previous errors */ });
-    this._deferredAllocation = new Deferred();
-    this._pendingAllocation = this._deviceRegistry.registerDevice(() => this._deferredAllocation.promise);
-
-    try {
-      return await this._doAllocate(deviceConfig);
-    } catch (e) {
-      this._deferredAllocation.reject(e);
-      throw e;
-    }
-  }
-
-  /**
-   * @param deviceConfig
-   * @returns {Promise<AndroidEmulatorCookie>}
-   */
-  async _doAllocate(deviceConfig) {
     const avdName = deviceConfig.device.avdName;
 
     await this._avdValidator.validate(avdName, deviceConfig.headless);
     await this._fixAvdConfigIniSkinNameIfNeeded(avdName, deviceConfig.headless);
 
-    let adbName = await this._freeDeviceFinder.findFreeDevice(avdName);
-    if (!adbName) {
-      const port = await this._freePortFinder.findFreePort();
-      adbName = `emulator-${port}`;
-
-      await this._emulatorLauncher.launch({
-        bootArgs: deviceConfig.bootArgs,
-        gpuMode: deviceConfig.gpuMode,
-        headless: deviceConfig.headless,
-        readonly: deviceConfig.readonly,
-        avdName,
-        adbName,
-        port,
-      });
-    }
-
-    return new AndroidEmulatorCookie(adbName);
-  }
-
-  /**
-    * @param {AndroidEmulatorCookie} deviceCookie
-    */
-  async postAllocate(deviceCookie) {
-    try {
-      await this._doPostAllocate(deviceCookie);
-      this._deferredAllocation.resolve(deviceCookie.adbName);
-    } catch (e) {
-      this._deferredAllocation.reject(e);
-      throw e;
-    }
+    const adbName = await this._deviceRegistry.registerDevice(async () => {
+      let adbName = await this._freeDeviceFinder.findFreeDevice(avdName);
+      if (!adbName) {
+        const port = await this._freePortFinder.findFreePort();
+        adbName = `emulator-${port}`;
+
+        await this._emulatorLauncher.launch({
+          bootArgs: deviceConfig.bootArgs,
+          gpuMode: deviceConfig.gpuMode,
+          headless: deviceConfig.headless,
+          readonly: deviceConfig.readonly,
+          avdName,
+          adbName,
+          port,
+        });
+      }
+
+      return adbName;
+    });
+
+    return {
+      id: adbName,
+      adbName,
+      name: `${adbName} (${avdName})`,
+    };
   }
 
   /**
-   * @param {AndroidEmulatorCookie} deviceCookie
-   * @returns {Promise<void>}
+   * @param {AndroidDeviceCookie} deviceCookie
    */
-  async _doPostAllocate(deviceCookie) {
+  async postAllocate(deviceCookie) {
     const { adbName } = deviceCookie;
 
     await this._emulatorLauncher.awaitEmulatorBoot(adbName);
@@ -123,7 +100,7 @@ class EmulatorAllocDriver extends AllocationDriverBase {
   }
 
   /**
-   * @param cookie {AndroidEmulatorCookie}
+   * @param cookie {AndroidDeviceCookie}
    * @param options {Partial<import('../../AllocationDriverBase').DeallocOptions>}
    * @return {Promise<void>}
    */