detox 21.0.0-breaking.new-global-lifecycle.0 → 21.0.1-rc.0

package/src/configuration/index.js

@@ -105,18 +105,23 @@ async function composeDetoxConfig({
   });
 
   const result = {
-    appsConfig,
-    artifactsConfig,
-    behaviorConfig,
-    cliConfig,
     configurationName,
-    deviceConfig,
-    errorComposer,
-    loggerConfig,
-    runnerConfig,
-    sessionConfig,
+
+    apps: appsConfig,
+    artifacts: artifactsConfig,
+    behavior: behaviorConfig,
+    cli: cliConfig,
+    device: deviceConfig,
+    logger: loggerConfig,
+    testRunner: runnerConfig,
+    session: sessionConfig,
   };
 
+  Object.defineProperty(result, 'errorComposer', {
+    enumerable: false,
+    value: errorComposer,
+  });
+
   return result;
 }
 

package/src/configuration/loadExternalConfig.js

@@ -6,7 +6,7 @@ const fs = require('fs-extra');
 const _ = require('lodash');
 const resolveFrom = require('resolve-from');
 
-const log = require('../utils/logger').child({ __filename });
+const log = require('../utils/logger').child({ cat: 'config' });
 
 async function locateExternalConfig(cwd) {
   return findUp([

package/src/devices/allocation/DeviceAllocator.js

@@ -1,5 +1,6 @@
 // @ts-nocheck
-const { traceMethods } = require('../../utils/trace');
+const log = require('../../utils/logger').child({ cat: 'device' });
+const traceMethods = require('../../utils/traceMethods');
 
 class DeviceAllocator {
   /**
@@ -7,7 +8,7 @@ class DeviceAllocator {
    */
   constructor(allocationDriver) {
     this._driver = allocationDriver;
-    traceMethods(this, 'device', ['allocate', 'free']);
+    traceMethods(log, this, ['allocate', 'postAllocate', 'free']);
   }
 
   /**
@@ -18,6 +19,18 @@ class DeviceAllocator {
     return this._driver.allocate(deviceConfig);
   }
 
+  /**
+   * @param {DeviceCookie} deviceCookie
+   * @return {Promise<unknown>}
+   */
+  postAllocate(deviceCookie) {
+    if (typeof this._driver.postAllocate !== 'function') {
+      return Promise.resolve();
+    }
+
+    return this._driver.postAllocate(deviceCookie);
+  }
+
   /**
    * @param cookie { DeviceCookie }
    * @param options { DeallocOptions }

package/src/devices/allocation/drivers/AllocationDriverBase.js

@@ -1,4 +1,6 @@
+/* eslint @typescript-eslint/no-unused-vars: ["error", { "args": "none" }] */
 // @ts-nocheck
+
 /**
  * @typedef DeallocOptions
  * @property shutdown { Boolean }
@@ -9,14 +11,20 @@ class AllocationDriverBase {
    * @param deviceConfig { Object }
    * @return {Promise<DeviceCookie>}
    */
-  async allocate(deviceConfig) {} // eslint-disable-line no-unused-vars
+  async allocate(deviceConfig) {}
+
+  /**
+   * @param {DeviceCookie} deviceCookie
+   * @return {Promise<void>}
+   */
+  async postAllocate(deviceCookie) {}
 
   /**
    * @param cookie { DeviceCookie }
    * @param options { DeallocOptions }
    * @return {Promise<void>}
    */
-  async free(cookie, options) {} // eslint-disable-line no-unused-vars
+  async free(cookie, options) {}
 }
 
 module.exports = AllocationDriverBase;

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

@@ -25,11 +25,20 @@ class AttachedAndroidAllocDriver extends AllocationDriverBase {
     const adbNamePattern = deviceConfig.device.adbName;
     const adbName = await this._deviceRegistry.allocateDevice(() => this._freeDeviceFinder.findFreeDevice(adbNamePattern));
 
+    return new AttachedAndroidDeviceCookie(adbName);
+  }
+
+  /**
+   * @param {AttachedAndroidDeviceCookie} deviceCookie
+   * @returns {Promise<void>}
+   */
+  async postAllocate(deviceCookie) {
+    const { adbName } = deviceCookie;
+
     // TODO Also disable native animations?
     await this._adb.apiLevel(adbName);
     await this._adb.unlockScreen(adbName);
     await this._attachedAndroidLauncher.notifyLaunchCompleted(adbName);
-    return new AttachedAndroidDeviceCookie(adbName);
   }
 
   /**

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

@@ -2,7 +2,7 @@ const _ = require('lodash');
 
 const DetoxRuntimeError = require('../../../../../errors/DetoxRuntimeError');
 const environment = require('../../../../../utils/environment');
-const logger = require('../../../../../utils/logger').child({ __filename });
+const logger = require('../../../../../utils/logger').child({ cat: 'device' });
 
 const REQUIRED_EMULATOR_MAJOR = 29;
 
@@ -12,11 +12,11 @@ class AVDValidator {
     this._emulatorVersionResolver = emulatorVersionResolver;
   }
 
-  async validate(avdName) {
+  async validate(avdName, isHeadless) {
     const avds = await this._avdsResolver.resolve(avdName);
     this._assertAVDs(avds);
     await this._assertAVDMatch(avds, avdName);
-    await this._validateEmulatorVer();
+    await this._validateEmulatorVer(isHeadless);
   }
 
   _assertAVDs(avds) {
@@ -37,8 +37,8 @@ class AVDValidator {
     }
   }
 
-  async _validateEmulatorVer() {
-    const emulatorVersion = await this._emulatorVersionResolver.resolve();
+  async _validateEmulatorVer(isHeadless) {
+    const emulatorVersion = await this._emulatorVersionResolver.resolve(isHeadless);
     if (!emulatorVersion) {
       logger.warn({ event: 'AVD_VALIDATION' }, 'Emulator version detection failed (See previous logs)');
       return;

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

@@ -1,7 +1,6 @@
 // @ts-nocheck
 const _ = require('lodash');
 
-const { traceMethods } = require('../../../../../utils/trace');
 const AndroidEmulatorCookie = require('../../../../cookies/AndroidEmulatorCookie');
 const AllocationDriverBase = require('../../AllocationDriverBase');
 
@@ -22,8 +21,7 @@ class EmulatorAllocDriver extends AllocationDriverBase {
     this._emulatorVersionResolver = emulatorVersionResolver;
     this._emulatorLauncher = emulatorLauncher;
     this._allocationHelper = allocationHelper;
-
-    traceMethods(this, 'device', ['_launchEmulator']);
+    this._launchInfo = {};
   }
 
   /**
@@ -33,25 +31,41 @@ class EmulatorAllocDriver extends AllocationDriverBase {
   async allocate(deviceConfig) {
     const avdName = deviceConfig.device.avdName;
 
-    await this._avdValidator.validate(avdName);
+    await this._avdValidator.validate(avdName, deviceConfig.headless);
     await this._fixAvdConfigIniSkinNameIfNeeded(avdName, deviceConfig.headless);
 
     const allocResult = await this._allocationHelper.allocateDevice(avdName);
-    const { adbName, placeholderPort, isRunning } = allocResult;
-    const launchOptions = {
-      bootArgs: deviceConfig.bootArgs,
-      gpuMode: deviceConfig.gpuMode,
-      headless: deviceConfig.headless,
-      readonly: deviceConfig.readonly,
-      port: placeholderPort,
+    const { adbName } = allocResult;
+
+    this._launchInfo[adbName] = {
+      avdName,
+      isRunning: allocResult.isRunning,
+      launchOptions: {
+        bootArgs: deviceConfig.bootArgs,
+        gpuMode: deviceConfig.gpuMode,
+        headless: deviceConfig.headless,
+        readonly: deviceConfig.readonly,
+        port: allocResult.placeholderPort,
+      },
     };
 
-    await this._launchEmulator(avdName, adbName, isRunning, launchOptions);
-    await this._prepareEmulator(adbName);
-
     return new AndroidEmulatorCookie(adbName);
   }
 
+  /**
+   * @param {AndroidEmulatorCookie} deviceCookie
+   * @returns {Promise<void>}
+   */
+  async postAllocate(deviceCookie) {
+    const { adbName } = deviceCookie;
+    const { avdName, isRunning, launchOptions } = this._launchInfo[adbName];
+
+    await this._emulatorLauncher.launch(avdName, adbName, isRunning, launchOptions);
+    await this._adb.apiLevel(adbName);
+    await this._adb.disableAndroidAnimations(adbName);
+    await this._adb.unlockScreen(adbName);
+  }
+
   /**
    * @param cookie { AndroidEmulatorCookie }
    * @param options { DeallocOptions }
@@ -72,21 +86,6 @@ class EmulatorAllocDriver extends AllocationDriverBase {
     const binaryVersion = _.get(rawBinaryVersion, 'major');
     return await patchAvdSkinConfig(avdName, binaryVersion);
   }
-
-  async _launchEmulator(avdName, adbName, isRunning, options) {
-    try {
-      await this._emulatorLauncher.launch(avdName, adbName, isRunning, options);
-    } catch (e) {
-      await this._allocationHelper.deallocateDevice(adbName);
-      throw e;
-    }
-  }
-
-  async _prepareEmulator(adbName) {
-    await this._adb.apiLevel(adbName);
-    await this._adb.disableAndroidAnimations(adbName);
-    await this._adb.unlockScreen(adbName);
-  }
 }
 
 module.exports = EmulatorAllocDriver;

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

@@ -1,4 +1,4 @@
-const logger = require('../../../../../utils/logger').child({ __filename });
+const logger = require('../../../../../utils/logger').child({ cat: 'device' });
 const DeviceAllocationHelper  = require('../../../../common/drivers/DeviceAllocationHelper');
 
 const DetoxEmulatorsPortRange = {

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

@@ -1,7 +1,8 @@
 // @ts-nocheck
 const { DetoxRuntimeError } = require('../../../../../errors');
+const log = require('../../../../../utils/logger').child({ cat: 'device' });
 const retry = require('../../../../../utils/retry');
-const { traceMethods } = require('../../../../../utils/trace');
+const traceMethods = require('../../../../../utils/traceMethods');
 const DeviceLauncher = require('../../../../common/drivers/DeviceLauncher');
 const { LaunchCommand } = require('../../../../common/drivers/android/emulator/exec/EmulatorExec');
 
@@ -14,7 +15,7 @@ class EmulatorLauncher extends DeviceLauncher {
     super(eventEmitter);
     this._adb = adb;
     this._emulatorExec = emulatorExec;
-    traceMethods(this, 'device', ['_awaitEmulatorBoot']);
+    traceMethods(log, this, ['_awaitEmulatorBoot']);
   }
 
   /**
@@ -35,7 +36,7 @@ class EmulatorLauncher extends DeviceLauncher {
         retries: 2,
         interval: 100,
         conditionFn: isUnknownEmulatorError,
-      }, () => this._launchEmulator(avdName, launchCommand));
+      }, () => this._launchEmulator(avdName, launchCommand, adbName));
     }
     await this._awaitEmulatorBoot(adbName);
     await this._notifyBootEvent(adbName, avdName, !isRunning);
@@ -59,8 +60,8 @@ class EmulatorLauncher extends DeviceLauncher {
     await this._notifyShutdownCompleted(adbName);
   }
 
-  _launchEmulator(emulatorName, launchCommand) {
-    return launchEmulatorProcess(emulatorName, this._emulatorExec, launchCommand);
+  _launchEmulator(emulatorName, launchCommand, adbName) {
+    return launchEmulatorProcess(emulatorName, this._emulatorExec, launchCommand, this._adb, adbName);
   }
 
   async _awaitEmulatorBoot(adbName) {

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

@@ -1,8 +1,6 @@
-const log = require('../../../../../utils/logger').child({ __filename });
+const log = require('../../../../../utils/logger').child({ cat: 'device' });
 const { QueryVersionCommand } = require('../../../../common/drivers/android/emulator/exec/EmulatorExec');
 
-const EMU_BIN_VERSION_DETECT_EV = 'EMU_BIN_VERSION_DETECT';
-
 class EmulatorVersionResolver {
   constructor(emulatorExec) {
     this._emulatorExec = emulatorExec;
@@ -21,18 +19,18 @@ class EmulatorVersionResolver {
     try {
       rawOutput = await this._emulatorExec.exec(new QueryVersionCommand({ headless })) || '';
     } catch (error) {
-      log.error({ event: EMU_BIN_VERSION_DETECT_EV, success: false, error }, 'Could not detect emulator binary version', error);
+      log.error({ success: false, error }, 'Could not detect emulator binary version', error);
       return null;
     }
 
     const matches = rawOutput.match(/Android emulator version ([0-9]+\.[0-9]+\.[0-9]+\.[0-9]*)/);
     if (!matches) {
-      log.warn({ event: EMU_BIN_VERSION_DETECT_EV, success: false }, 'Could not detect emulator binary version, got:', rawOutput);
+      log.warn({ success: false }, 'Could not detect emulator binary version, got:', rawOutput);
       return null;
     }
 
     const version = this._parseVersionString(matches[1]);
-    log.debug({ event: EMU_BIN_VERSION_DETECT_EV, success: true }, 'Detected emulator binary version', version);
+    log.debug({ success: true }, 'Detected emulator binary version', version);
     return version;
   }
 

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

@@ -1,29 +1,15 @@
 const fs = require('fs');
 
 const _ = require('lodash');
-const { Tail } = require('tail');
 
-const unitLogger = require('../../../../../utils/logger').child({ __filename });
+const unitLogger = require('../../../../../utils/logger').child({ cat: 'device' });
 
-function launchEmulatorProcess(emulatorName, emulatorExec, emulatorLaunchCommand) {
+function launchEmulatorProcess(emulatorName, emulatorExec, emulatorLaunchCommand, adb, adbName) {
   let childProcessOutput;
-
   const portName = emulatorLaunchCommand.port ? `-${emulatorLaunchCommand.port}` : '';
   const tempLog = `./${emulatorName}${portName}.log`;
   const stdout = fs.openSync(tempLog, 'a');
   const stderr = fs.openSync(tempLog, 'a');
-  const tailOptions = {
-    useWatchFile: true,
-    fsWatchOptions: {
-      interval: 1500,
-    },
-  };
-  const tail = new Tail(tempLog, tailOptions)
-    .on('line', (line) => {
-      if (line.includes('Adb connected, start proxing data')) {
-        childProcessPromise._cpResolve();
-      }
-    });
 
   function detach() {
     if (childProcessOutput) {
@@ -32,7 +18,6 @@ function launchEmulatorProcess(emulatorName, emulatorExec, emulatorLaunchCommand
 
     childProcessOutput = fs.readFileSync(tempLog, 'utf8');
 
-    tail.unwatch();
     fs.closeSync(stdout);
     fs.closeSync(stderr);
     fs.unlink(tempLog, _.noop);
@@ -46,6 +31,8 @@ function launchEmulatorProcess(emulatorName, emulatorExec, emulatorLaunchCommand
 
   log = log.child({ child_pid: childProcessPromise.childProcess.pid });
 
+  adb.waitForDevice(adbName).then(() => childProcessPromise._cpResolve());
+
   return childProcessPromise.then(() => true).catch((err) => {
     detach();
 

package/src/devices/allocation/drivers/android/genycloud/GenyAllocDriver.js

@@ -1,22 +1,25 @@
-// @ts-nocheck
-const DetoxRuntimeError = require('../../../../../errors/DetoxRuntimeError');
+const { DetoxRuntimeError } = require('../../../../../errors');
+const Timer = require('../../../../../utils/Timer');
 const GenycloudEmulatorCookie = require('../../../../cookies/GenycloudEmulatorCookie');
 const AllocationDriverBase = require('../../AllocationDriverBase');
 
 class GenyAllocDriver extends AllocationDriverBase {
 
   /**
-   * @param adb { ADB }
-   * @param recipeQuerying { GenyRecipeQuerying }
-   * @param allocationHelper { GenyInstanceAllocationHelper }
-   * @param instanceLauncher { GenyInstanceLauncher }
+   * @param {object} options
+   * @param {import('../../../../common/drivers/android/exec/ADB')} options.adb
+   * @param {import('./GenyRecipeQuerying')} options.recipeQuerying
+   * @param {import('./GenyInstanceAllocationHelper')} options.allocationHelper
+   * @param {import('./GenyInstanceLauncher')} options.instanceLauncher
    */
   constructor({ adb, recipeQuerying, allocationHelper, instanceLauncher }) {
     super();
+
     this._adb = adb;
     this._recipeQuerying = recipeQuerying;
     this._instanceLauncher = instanceLauncher;
     this._instanceAllocationHelper = allocationHelper;
+    this._launchInfo = {};
   }
 
   /**
@@ -28,20 +31,26 @@ class GenyAllocDriver extends AllocationDriverBase {
     const recipe = await this._recipeQuerying.getRecipeFromQuery(deviceQuery);
     this._assertRecipe(deviceQuery, recipe);
 
-    const allocResult = await this._instanceAllocationHelper.allocateDevice(recipe);
-    let { instance, isNew } = allocResult;
+    const { instance, isNew } = await this._instanceAllocationHelper.allocateDevice(recipe);
+    this._launchInfo[instance.uuid] = { isNew };
+    return new GenycloudEmulatorCookie(instance);
+  }
 
-    try {
-      instance = await this._instanceLauncher.launch(instance, isNew);
-    } catch (e) {
-      await this._instanceAllocationHelper.deallocateDevice(instance.uuid);
-      throw e;
-    }
-    const { adbName } = instance;
+  /**
+   * @param {GenycloudEmulatorCookie} cookie
+   * @returns {Promise<void>}
+   */
+  async postAllocate(cookie) {
+    const { instance } = cookie;
+    const { isNew } = this._launchInfo[instance.uuid];
+    const readyInstance = cookie.instance = await this._instanceLauncher.launch(instance, isNew);
 
-    await this._adb.disableAndroidAnimations(adbName);
-    await this._adb.apiLevel(adbName);
-    return new GenycloudEmulatorCookie(instance);
+    const { adbName } = readyInstance;
+    await Timer.run(20000, 'waiting for device to respond', async () => {
+      await this._adb.disableAndroidAnimations(adbName);
+      await this._adb.setWiFiToggle(adbName, true);
+      await this._adb.apiLevel(adbName);
+    });
   }
 
   /**

package/src/devices/allocation/drivers/android/genycloud/GenyInstanceAllocationHelper.js

@@ -1,5 +1,5 @@
 // @ts-nocheck
-const logger = require('../../../../../utils/logger').child({ __filename });
+const logger = require('../../../../../utils/logger').child({ cat: 'device' });
 const DeviceAllocationHelper = require('../../../../common/drivers/DeviceAllocationHelper');
 
 const { ALLOCATE_DEVICE_LOG_EVT } = DeviceAllocationHelper;

package/src/devices/allocation/drivers/ios/SimulatorAllocDriver.js

@@ -16,6 +16,7 @@ class SimulatorAllocDriver extends AllocationDriverBase {
     this._deviceRegistry = deviceRegistry;
     this._applesimutils = applesimutils;
     this._simulatorLauncher = simulatorLauncher;
+    this._launchInfo = {};
   }
 
   /**
@@ -35,16 +36,20 @@ class SimulatorAllocDriver extends AllocationDriverBase {
       throw new DetoxRuntimeError(`Failed to find device matching ${deviceComment}`);
     }
 
-    try {
-      await this._simulatorLauncher.launch(udid, deviceConfig.type, deviceConfig.bootArgs, deviceConfig.headless);
-    } catch (e) {
-      await this._deviceRegistry.disposeDevice(udid);
-      throw e;
-    }
-
+    this._launchInfo[udid] = { deviceConfig };
     return new IosSimulatorCookie(udid);
   }
 
+  /**
+   * @param {IosSimulatorCookie} deviceCookie
+   * @returns {Promise<void>}
+   */
+  async postAllocate(deviceCookie) {
+    const { udid } = deviceCookie;
+    const { deviceConfig } = this._launchInfo[udid];
+    await this._simulatorLauncher.launch(udid, deviceConfig.type, deviceConfig.bootArgs, deviceConfig.headless);
+  }
+
   /**
    * @param cookie { IosSimulatorCookie }
    * @param options { DeallocOptions }

package/src/devices/allocation/factories/base.js

@@ -16,7 +16,7 @@ class DeviceAllocatorFactory {
    * @returns { AllocationDriverBase }
    * @private
    */
-  _createDriver(deps) {} // eslint-disable-line no-unused-vars
+  _createDriver(deps) {} // eslint-disable-line @typescript-eslint/no-unused-vars
 }
 
 module.exports = DeviceAllocatorFactory;

package/src/devices/common/drivers/android/exec/ADB.js

@@ -189,6 +189,10 @@ class ADB {
     }
   }
 
+  async waitForDevice(deviceId) {
+    return await this.adbCmd(deviceId, 'wait-for-device');
+  }
+
   async apiLevel(deviceId) {
     if (this._cachedApiLevels.has(deviceId)) {
       return this._cachedApiLevels.get(deviceId);
@@ -206,6 +210,11 @@ class ADB {
     await this.shell(deviceId, `settings put global transition_animation_scale 0`);
   }
 
+  async setWiFiToggle(deviceId, state) {
+    const value = (state === true ? 'enable' : 'disable');
+    await this.shell(deviceId, `svc wifi ${value}`);
+  }
+
   async screencap(deviceId, path) {
     await this.shell(deviceId, `screencap ${path}`);
   }

package/src/devices/common/drivers/android/genycloud/exec/GenyCloudExec.js

@@ -28,7 +28,7 @@ class GenyCloudExec {
   }
 
   startInstance(recipeUUID, instanceName) {
-    return this._exec(`instances start --stop-when-inactive --no-wait ${recipeUUID} "${instanceName}"`, { retries: 0 });
+    return this._exec(`instances start --no-wait ${recipeUUID} "${instanceName}"`, { retries: 0 });
   }
 
   adbConnect(instanceUUID) {

package/src/devices/common/drivers/android/genycloud/services/GenyInstanceNaming.js

@@ -1,9 +1,9 @@
-const session = () => require('../../../../../../../internals').session;
+const internals = () => require('../../../../../../../internals');
 
 class GenyInstanceNaming {
   generateName() {
-    const { id, workerId } = session();
-    return `Detox.${id}.${workerId}`;
+    const { session, worker } = internals();
+    return `Detox.${session.id}.${worker.id}`;
   }
 
   isFamilial(name) {

package/src/devices/common/drivers/android/genycloud/services/GenyRecipesService.js

@@ -1,4 +1,4 @@
-const logger = require('../../../../../../utils/logger').child({ __filename });
+const logger = require('../../../../../../utils/logger').child({ cat: 'device' });
 
   const Recipe = require('./dto/GenyRecipe');
 

package/src/devices/common/drivers/android/tools/AppInstallHelper.js

@@ -1,13 +1,13 @@
 // TODO Tweak such that if apk's already exist on the device (need to store uniquely), they will not be resent (would optimize cloud, for example)
 
 class AppInstallHelper {
-  constructor(adb, fileXfer) {
+  constructor(adb, fileTransfer) {
     this._adb = adb;
-    this._fileXfer = fileXfer;
+    this._fileTransfer = fileTransfer;
   }
 
   async install(deviceId, appBinaryPath, testBinaryPath) {
-    await this._fileXfer.prepareDestinationDir(deviceId);
+    await this._fileTransfer.prepareDestinationDir(deviceId);
     await this._pushAndInstallBinary(deviceId, appBinaryPath, 'Application.apk');
     if (testBinaryPath) {
       await this._pushAndInstallBinary(deviceId, testBinaryPath, 'Test.apk');
@@ -15,7 +15,7 @@ class AppInstallHelper {
   }
 
   async _pushAndInstallBinary(deviceId, binaryPath, binaryFilenameOnTarget) {
-    const binaryPathOnTarget = await this._fileXfer.send(deviceId, binaryPath, binaryFilenameOnTarget);
+    const binaryPathOnTarget = await this._fileTransfer.send(deviceId, binaryPath, binaryFilenameOnTarget);
     await this._adb.remoteInstall(deviceId, binaryPathOnTarget);
   }
 }

package/src/devices/common/drivers/android/tools/EmulatorTelnet.js

@@ -5,7 +5,7 @@ const path = require('path');
 const fs = require('fs-extra');
 const Telnet = require('telnet-client');
 
-const log = require('../../../../../utils/logger').child({ __filename });
+const log = require('../../../../../utils/logger').child({ cat: 'device' });
 
 class EmulatorTelnet {
   constructor() {

package/src/devices/common/drivers/android/tools/{FileXfer.js → FileTransfer.js}

@@ -1,6 +1,6 @@
 const path = require('path');
 
-class FileXfer {
+class FileTransfer {
   constructor(adb, destinationDir) {
     this._adb = adb;
     this._dir = destinationDir;
@@ -18,4 +18,4 @@ class FileXfer {
   }
 }
 
-module.exports = FileXfer;
+module.exports = FileTransfer;

package/src/devices/common/drivers/android/tools/FreeDeviceFinder.js

@@ -1,4 +1,4 @@
-const log = require('../../../../../utils/logger').child({ __filename });
+const log = require('../../../../../utils/logger').child({ cat: 'device' });
 
 const DEVICE_LOOKUP_LOG_EVT = 'DEVICE_LOOKUP';
 

package/src/devices/common/drivers/android/tools/MonitoredInstrumentation.js

@@ -77,7 +77,7 @@ class MonitoredInstrumentation {
         'while it was waiting for "ready" message (over WebSocket) ' +
         'from the instrumentation process.',
       debugInfo: this.instrumentationStackTrace
-        ? `Native stacktrace dump: ${this.instrumentationStackTrace}`
+        ? `Native stacktrace dump:\n${this.instrumentationStackTrace}`
         : '',
     });
   }

package/src/devices/common/drivers/android/tools/TempFileTransfer.js

@@ -0,0 +1,14 @@
+const FileTransfer = require('./FileTransfer');
+
+const FILE_PATH = '/data/local/tmp/detox';
+
+class TempFileTransfer extends FileTransfer {
+  constructor(adb) {
+    super(adb, FILE_PATH);
+  }
+}
+
+module.exports = {
+  TempFileTransfer,
+  FILE_PATH
+};