wix · d4vidi · Jan 5, 2026 · Jan 7, 2026 · Jan 7, 2026 · Jan 8, 2026
@@ -5,7 +5,6 @@
     env:
       REACT_NATIVE_VERSION: 0.83.0
       RCT_NEW_ARCH_ENABLED: 1
-      TEST_GENYCLOUD_SANITY: true
       DETOX_DISABLE_POD_INSTALL: true
       DETOX_DISABLE_POSTINSTALL: true
     artifact_paths:

@@ -5,6 +5,8 @@
     env:
       REACT_NATIVE_VERSION: 0.83.0
       RCT_NEW_ARCH_ENABLED: 1
+      TEST_GENYCLOUD_SANITY: true # Only set 'true' in jobs with the latest supported RN
+      TEST_SINGLE_ADB_SERVER_SANITY: true # Only set 'true' in jobs with the latest supported RN
       DETOX_DISABLE_POD_INSTALL: true
       DETOX_DISABLE_POSTINSTALL: true
     artifact_paths:

@@ -434,6 +434,13 @@ declare global {
              * @default true
              */
             readonly?: boolean;
+            /**
+             * When `true`, each emulator uses its own separate ADB server on a separate port. This is the
+             * opposite of Android's default, which is to share a single ADB server on the default port (5037). The default
+             * has been found to be unstable and is therefore not recommended.
+             * @default true
+             */
+            useSeparateAdbServers?: boolean;
         }
 
         interface DetoxGenymotionCloudDriverConfig extends DetoxSharedAndroidDriverConfig {

@@ -71,6 +71,7 @@ module.exports = {
     'src/utils/pressAnyKey.js',
     'src/utils/repl.js',
     'src/utils/shellUtils.js',
+    'src/utils/netUtils.js',
     'runners/jest/reporters',
     'runners/jest/testEnvironment',
     'src/DetoxWorker.js',

@@ -186,6 +186,8 @@ class DetoxWorker {
       });
     }
 
+    // @ts-ignore
+    yield this.device.init();
     // @ts-ignore
     yield this.device.installUtilBinaries();
 

@@ -1,19 +1,31 @@
+/**
+ * @typedef {import('../../../common/drivers/android/tools/DeviceHandle')} DeviceHandle
+ * @typedef {import('../../../common/drivers/android/tools/EmulatorHandle')} EmulatorHandle
+ */
+
 const log = require('../../../../utils/logger').child({ cat: 'device' });
 
 const DEVICE_LOOKUP = { event: 'DEVICE_LOOKUP' };
 
 class FreeDeviceFinder {
-  constructor(adb, deviceRegistry) {
-    this.adb = adb;
+  /**
+   * @param {import('../../DeviceRegistry')} deviceRegistry
+   */
+  constructor(deviceRegistry) {
     this.deviceRegistry = deviceRegistry;
   }
 
-  async findFreeDevice(deviceQuery) {
-    const { devices } = await this.adb.devices();
+  /**
+   * @param {DeviceHandle[]} candidates
+   * @param {string} deviceQuery
+   * @returns {Promise<import('../../../common/drivers/android/tools/EmulatorHandle') | null>}
+   */
+  async findFreeDevice(candidates, deviceQuery) {
     const takenDevices = this.deviceRegistry.getTakenDevicesSync();
-    for (const candidate of devices) {
+    for (const candidate of candidates) {
       if (await this._isDeviceFreeAndMatching(takenDevices, candidate, deviceQuery)) {
-        return candidate.adbName;
+        // @ts-ignore
+        return candidate;
       }
     }
     return null;

@@ -4,8 +4,6 @@ const FreeDeviceFinder = require('./FreeDeviceFinder');
 const { deviceOffline, emulator5556, ip5557, localhost5555 } = require('./__mocks__/handles');
 
 describe('FreeDeviceFinder', () => {
-  const mockAdb = { devices: jest.fn() };
-
   /** @type {DeviceList} */
   let fakeDeviceList;
   let mockDeviceRegistry;
@@ -17,42 +15,34 @@ describe('FreeDeviceFinder', () => {
     mockDeviceRegistry = new DeviceRegistry();
     mockDeviceRegistry.getTakenDevicesSync.mockImplementation(() => fakeDeviceList);
 
-    uut = new FreeDeviceFinder(mockAdb, mockDeviceRegistry);
+    uut = new FreeDeviceFinder(mockDeviceRegistry);
   });
 
   it('should return the only device when it matches, is online and not already taken by other workers', async () => {
-    mockAdbDevices([emulator5556]);
-
-    const result = await uut.findFreeDevice(emulator5556.adbName);
-    expect(result).toEqual(emulator5556.adbName);
+    const result = await uut.findFreeDevice([emulator5556], emulator5556.adbName);
+    expect(result).toEqual(emulator5556);
   });
 
   it('should return null when there are no devices', async () => {
-    mockAdbDevices([]);
-
-    const result = await uut.findFreeDevice(emulator5556.adbName);
+    const result = await uut.findFreeDevice([], emulator5556.adbName);
     expect(result).toEqual(null);
   });
 
   it('should return null when device is already taken by other workers', async () => {
-    mockAdbDevices([emulator5556]);
     mockAllDevicesTaken();
 
-    expect(await uut.findFreeDevice(emulator5556.adbName)).toEqual(null);
+    expect(await uut.findFreeDevice([emulator5556], emulator5556.adbName)).toEqual(null);
   });
 
   it('should return null when device is offline', async () => {
-    mockAdbDevices([deviceOffline]);
-    expect(await uut.findFreeDevice(deviceOffline.adbName)).toEqual(null);
+    expect(await uut.findFreeDevice([deviceOffline], deviceOffline.adbName)).toEqual(null);
   });
 
   it('should return first device that matches a regular expression', async () => {
-    mockAdbDevices([emulator5556, localhost5555, ip5557]);
     const localhost = '^localhost:\\d+$';
-    expect(await uut.findFreeDevice(localhost)).toBe(localhost5555.adbName);
+    expect(await uut.findFreeDevice([emulator5556, localhost5555, ip5557], localhost)).toBe(localhost5555);
   });
 
-  const mockAdbDevices = (devices) => mockAdb.devices.mockResolvedValue({ devices });
   const mockAllDevicesTaken = () => {
     fakeDeviceList.add(emulator5556.adbName, { busy: true });
     fakeDeviceList.add(localhost5555.adbName, { busy: true });

@@ -27,7 +27,8 @@ class AttachedAndroidAllocDriver extends AndroidAllocDriver {
    */
   async allocate(deviceConfig) {
     const adbNamePattern = deviceConfig.device.adbName;
-    const adbName = await this._deviceRegistry.registerDevice(() => this._freeDeviceFinder.findFreeDevice(adbNamePattern));
+    const adbName = await this._deviceRegistry.registerDevice(async () =>
+      (await this._freeDeviceFinder.findFreeDevice(adbNamePattern)).adbName);
 
     return { id: adbName, adbName };
   }

@@ -1,10 +1,14 @@
 /**
  * @typedef {import('../../../../common/drivers/android/cookies').AndroidDeviceCookie} AndroidDeviceCookie
+ * @typedef {import('../../../../common/drivers/android/cookies').EmulatorDeviceCookie} EmulatorDeviceCookie
+ * @typedef {import('../../../../common/drivers/android/tools/DeviceHandle')} DeviceHandle
  */
 
 const _ = require('lodash');
 
 const log = require('../../../../../utils/logger').child({ cat: 'device,device-allocation' });
+const { isPortTaken } = require('../../../../../utils/netUtils');
+const adbPortRegistry = require('../../../../common/drivers/android/AdbPortRegistry');
 const AndroidAllocDriver = require('../AndroidAllocDriver');
 
 const { patchAvdSkinConfig } = require('./patchAvdSkinConfig');
@@ -48,29 +52,47 @@ class EmulatorAllocDriver extends AndroidAllocDriver {
 
   /**
    * @param deviceConfig
-   * @returns {Promise<AndroidDeviceCookie>}
+   * @returns {Promise<EmulatorDeviceCookie>}
    */
   async allocate(deviceConfig) {
     const avdName = deviceConfig.device.avdName;
+    const useSeparateAdbServers = deviceConfig.useSeparateAdbServers === true;
 
     await this._avdValidator.validate(avdName, deviceConfig.headless);
     await this._fixAvdConfigIniSkinNameIfNeeded(avdName, deviceConfig.headless);
 
-    const adbName = await this._deviceRegistry.registerDevice(async () => {
-      let adbName = await this._freeDeviceFinder.findFreeDevice(avdName);
-      if (!adbName) {
+    let adbServerPort;
+    let adbName;
+
+    await this._deviceRegistry.registerDevice(async () => {
+      const candidates = await this._getAllDevices(useSeparateAdbServers);
+      const device = await this._freeDeviceFinder.findFreeDevice(candidates, avdName);
+
+      if (device) {
+        adbName = device.adbName;
+        adbServerPort = device.adbServerPort;
+        adbPortRegistry.register(adbName, adbServerPort);
+      } else {
         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,
-        });
+        adbName = `emulator-${port}`;
+        adbServerPort = this._getFreeAdbServerPort(candidates, useSeparateAdbServers);
+        adbPortRegistry.register(adbName, adbServerPort);
+
+        try {
+          await this._emulatorLauncher.launch({
+            bootArgs: deviceConfig.bootArgs,
+            gpuMode: deviceConfig.gpuMode,
+            headless: deviceConfig.headless,
+            readonly: deviceConfig.readonly,
+            avdName,
+            adbName,
+            port,
+            adbServerPort,
+          });
+        } catch (e) {
+          adbPortRegistry.unregister(adbName);
+        }
       }
 
       return adbName;
@@ -80,6 +102,7 @@ class EmulatorAllocDriver extends AndroidAllocDriver {
       id: adbName,
       adbName,
       name: `${adbName} (${avdName})`,
+      adbServerPort,
     };
   }
 
@@ -111,14 +134,16 @@ class EmulatorAllocDriver extends AndroidAllocDriver {
     if (options.shutdown) {
       await this._doShutdown(adbName);
       await this._deviceRegistry.unregisterDevice(adbName);
+
+      adbPortRegistry.unregister(adbName);
     } else {
       await this._deviceRegistry.releaseDevice(adbName);
     }
   }
 
   async cleanup() {
     if (this._shouldShutdown) {
-      const { devices } = await this._adb.devices();
+      const devices = await this._getAllDevices(true);
       const actualEmulators = devices.map((device) => device.adbName);
       const sessionDevices = await this._deviceRegistry.readSessionDevices();
       const emulatorsToShutdown = _.intersection(sessionDevices.getIds(), actualEmulators);
@@ -146,6 +171,41 @@ class EmulatorAllocDriver extends AndroidAllocDriver {
     const binaryVersion = _.get(rawBinaryVersion, 'major');
     return await patchAvdSkinConfig(avdName, binaryVersion);
   }
+
+  /**
+   * @param {boolean} useSeparateAdbServers
+   * @returns {Promise<DeviceHandle[]>}
+   * @private
+   */
+  async _getAllDevices(useSeparateAdbServers) {
+    const adbServers = await this._getRunningAdbServers(useSeparateAdbServers);
+    return (await this._adb.devices({}, adbServers)).devices;
+  }
+
+  /**
+   * @param {boolean} useSeparateAdbServers
+   * @returns {Promise<number[]>}
+   * @private
+   */
+  async _getRunningAdbServers(useSeparateAdbServers = true) {
+    const ports = [this._adb.defaultServerPort];
+
+    if (useSeparateAdbServers) {
+        for (let port = this._adb.defaultServerPort + 1; await isPortTaken(port); port++) {
+          ports.push(port);
+        }
+    }    
+    return ports;
+  }
+
+  _getFreeAdbServerPort(currentDevices, useSeparateAdbServers) {
+    if (!useSeparateAdbServers) {
+      return this._adb.defaultServerPort;
+    }
+
+    const maxPortDevice = _.maxBy(currentDevices, 'adbServerPort');
+    return _.get(maxPortDevice, 'adbServerPort', this._adb.defaultServerPort) + 1;
+  }
 }
 
 module.exports = EmulatorAllocDriver;
@@ -17,6 +17,7 @@ class EmulatorLauncher {
    * @param {object} options
    * @param {string} options.avdName
    * @param {string} options.adbName
+   * @param {number} options.adbServerPort
    * @param {number} options.port
    * @param {string | undefined} options.bootArgs
    * @param {string | undefined} options.gpuMode
@@ -29,7 +30,7 @@ class EmulatorLauncher {
       retries: 2,
       interval: 100,
       conditionFn: isUnknownEmulatorError,
-    }, () => launchEmulatorProcess(this._emulatorExec, this._adb, launchCommand));
+    }, () => launchEmulatorProcess(this._emulatorExec, this._adb, launchCommand, options.adbServerPort));
   }
 
   /**

@@ -38,7 +38,7 @@ describe('Emulator launcher', () => {
       expect(launchEmulatorProcess).toHaveBeenCalledWith(emulatorExec, adb, expect.objectContaining({
         avdName,
         adbName,
-      }));
+      }), undefined);
     });
 
     it('should launch using a specific emulator port, if provided', async () => {
@@ -49,6 +49,13 @@ describe('Emulator launcher', () => {
       expect(command.port).toEqual(port);
     });
 
+    it('should pass adbServerPort to launchEmulatorProcess', async () => {
+      const adbServerPort = 5038;
+      await uut.launch({ avdName, adbName, adbServerPort });
+
+      expect(launchEmulatorProcess).toHaveBeenCalledWith(emulatorExec, adb, expect.anything(), adbServerPort);
+    });
+
     it('should retry emulator process launching with custom args', async () => {
       const expectedRetryOptions = {
         retries: 2,

@@ -30,7 +30,7 @@ class EmulatorVersionResolver {
     }
 
     const version = this._parseVersionString(matches[1]);
-    log.debug({ success: true }, 'Detected emulator binary version', version);
+    log.debug({ success: true }, `Detected emulator binary version ${version}`);
     return version;
   }
 

@@ -97,6 +97,6 @@ describe('Emulator binary version', () => {
 
   it('should log the version', async () => {
     await uut.resolve();
-    expect(log.debug).toHaveBeenCalledWith({ success: true }, expect.any(String), expect.objectContaining(expectedVersion));
+    expect(log.debug).toHaveBeenCalledWith({ success: true }, `Detected emulator binary version ${expectedVersionRaw}`);
   });
 });
@@ -1,6 +1,13 @@
 const FreeDeviceFinder = require('../FreeDeviceFinder');
 
 class FreeEmulatorFinder extends FreeDeviceFinder {
+  /**
+   * @param {import('../../../DeviceRegistry')} deviceRegistry
+   */
+  constructor(deviceRegistry) {
+    super(deviceRegistry);
+  }
+
   /**
    * @override
    */