feat: adb logcat is using --pid argument by default

detox/src/Detox.js

@@ -62,7 +62,7 @@ class Detox {
     this.artifactsManager = new ArtifactsManager({
       artifactCapabilities: deviceDriver.getArtifactCapabilities({
         deviceId: this.device.id,
-        bundleId: this.device.bundleId,
+        processId: this.device.processId,
       }),
     });
 

detox/src/artifacts/log/android/ADBLogcatRecorder.js

@@ -6,15 +6,15 @@ class ADBLogcatRecorder extends Recorder {
     super(config);
 
     this.adb = config.adb;
-    this.bundleId = config.bundleId;
     this.deviceId = config.deviceId;
+    this.processId = config.processId;
     this._logsCounter = 0;
   }
 
   createRecording() {
     return new ADBLogcatRecording({
       adb: this.adb,
-      bundleId: this.bundleId,
+      processId: this.processId,
       deviceId: this.deviceId,
       pathToLogOnDevice: this._generatePathOnDevice(),
     });

detox/src/artifacts/log/android/ADBLogcatRecorder.test.js

@@ -8,21 +8,21 @@ describe(ADBLogcatRecorder, () => {
   it('should create recording', () => {
     const artifactsRegistry = { registerArtifact: jest.fn() };
     const adb = {};
-    const bundleId = 'bundle';
+    const processId = 1083;
     const deviceId = 'device';
 
     const recorder = new ADBLogcatRecorder({
       artifactsRegistry,
       adb,
-      bundleId,
       deviceId,
+      processId,
     });
 
     const recording = recorder.record();
     expect(artifactsRegistry.registerArtifact).toHaveBeenCalledWith(recording);
     expect(recording.adb).toBe(adb);
-    expect(recording.bundleId).toBe(bundleId);
     expect(recording.deviceId).toBe(deviceId);
+    expect(recording.processId).toBe(processId);
   });
 });
 

detox/src/artifacts/log/android/ADBLogcatRecording.js

@@ -2,21 +2,21 @@ const fs = require('fs-extra');
 const RecordingArtifact = require('../../core/artifact/RecordingArtifact');
 const ensureExtension = require('../../../utils/ensureExtension');
 const interruptProcess = require('../../../utils/interruptProcess');
-const {spawn} = require('child-process-promise');
+const sleep = require('../../../utils/sleep');
 
 class ADBLogcatRecording extends RecordingArtifact {
   constructor({
     adb,
-    bundleId,
     deviceId,
     pathToLogOnDevice,
+    processId,
   }) {
     super();
 
     this.adb = adb;
-    this.bundleId = bundleId;
     this.deviceId = deviceId;
     this.pathToLogOnDevice = pathToLogOnDevice;
+    this.processId = processId;
     this.processPromise = null;
   }
 
@@ -25,31 +25,50 @@ class ADBLogcatRecording extends RecordingArtifact {
 
     this.processPromise = this.adb.logcat(this.deviceId, {
       file: this.pathToLogOnDevice,
+      pid: this.processId,
       time: now,
     });
 
-    await this.adb.waitForFileRecording(this.deviceId, this.pathToLogOnDevice, false);
+    await this._waitUntilLogFileIsCreated();
   }
 
   async doStop() {
     if (this.processPromise) {
-      await interruptProcess(this.processPromise, 'SIGTERM');
+      await interruptProcess(this.processPromise);
     }
   }
 
   async doSave(artifactPath) {
     const logArtifactPath = ensureExtension(artifactPath, '.log');
 
     await fs.ensureFile(logArtifactPath);
-    await this.adb.waitForFileRelease(this.deviceId, this.pathToLogOnDevice);
+    await this._waitWhileLogIsOpenedByLogcat();
     await this.adb.pull(this.deviceId, this.pathToLogOnDevice, logArtifactPath);
     await this.adb.rm(this.deviceId, this.pathToLogOnDevice);
   }
 
   async doDiscard() {
-    await this.adb.waitForFileRelease(this.deviceId, this.pathToLogOnDevice);
+    await this._waitWhileLogIsOpenedByLogcat();
     await this.adb.rm(this.deviceId, this.pathToLogOnDevice);
   }
+
+  async _waitUntilLogFileIsCreated() {
+    let size;
+
+    do {
+      size = await this.adb.getFileSize(this.deviceId, this.pathToLogOnDevice);
+      await sleep(100);
+    } while (size === -1);
+  }
+
+  async _waitWhileLogIsOpenedByLogcat() {
+    let isFileOpen;
+
+    do {
+      isFileOpen = await this.adb.isFileOpen(this.deviceId, this.pathToLogOnDevice);
+      await sleep(500);
+    } while (isFileOpen);
+  }
 }
 
 module.exports = ADBLogcatRecording;

detox/src/artifacts/video/android/ADBVideoRecording.js

@@ -49,12 +49,30 @@ class ADBVideoRecording extends RecordingArtifact {
 
   async _delayWhileVideoFileIsEmpty() {
     await sleep(300); // wait while video is most likely empty
-    await this.adb.waitForFileRecording(this.deviceId, this.pathToVideoOnDevice);
+    await this._waitForFileRecording();
   }
 
   async _delayWhileVideoFileIsBusy() {
     await this.waitWhileVideoIsMostLikelyBusy;
-    await this.adb.waitForFileRelease(this.deviceId, this.pathToVideoOnDevice);
+    await this._waitForFileRelease();
+  }
+
+  async _waitForFileRecording() {
+    let size;
+
+    do {
+      size = await this.adb.getFileSize(this.deviceId, this.pathToVideoOnDevice);
+      await sleep(100);
+    } while (size < 1);
+  }
+
+  async _waitForFileRelease() {
+    let isFileOpen;
+
+    do {
+      isFileOpen = await this.adb.isFileOpen(this.deviceId, this.pathToVideoOnDevice);
+      await sleep(500);
+    } while (isFileOpen);
   }
 }
 

detox/src/devices/AndroidDriver.js

@@ -8,6 +8,7 @@ const ADB = require('./android/ADB');
 const AAPT = require('./android/AAPT');
 const APKPath = require('./android/APKPath');
 const DeviceDriverBase = require('./DeviceDriverBase');
+const sleep = require('../utils/sleep');
 
 const ADBLogcatRecorder = require('../artifacts/log/android/ADBLogcatRecorder');
 const ADBScreenshotter = require('../artifacts/screenshot/android/ADBScreenshotter');
@@ -26,15 +27,15 @@ class AndroidDriver extends DeviceDriverBase {
     this.aapt = new AAPT();
   }
 
-  getArtifactCapabilities({ deviceId, bundleId }) {
+  getArtifactCapabilities({ deviceId, processId }) {
     const adb = this.adb;
 
     return {
       log: (config) => new ADBLogcatRecorder({
         ...config,
         adb,
         deviceId,
-        bundleId,
+        processId,
       }),
       screenshot: (config) => new ADBScreenshotter({
         ...config,
@@ -95,7 +96,7 @@ class AndroidDriver extends DeviceDriverBase {
     if (this.instrumentationProcess) {
       const call = invoke.call(invoke.Android.Class("com.wix.detox.Detox"), 'launchMainActivity');
       await this.invocationManager.execute(call);
-      return this.instrumentationProcess.pid;
+      return this._queryPID(deviceId, bundleId);
     }
 
     const testRunner = await this.adb.getInstrumentationRunner(deviceId, bundleId);
@@ -116,7 +117,25 @@ class AndroidDriver extends DeviceDriverBase {
       this.terminateInstrumentation();
     });
 
-    return this.instrumentationProcess.pid;
+    return this._queryPID(deviceId, bundleId);
+  }
+
+  async _queryPID(deviceId, bundleId, waitAtStart = true) {
+    if (waitAtStart) {
+      await sleep(500);
+    }
+
+    for (let attempts = 5; attempts > 0; attempts--) {
+      const PID = await this.adb.pidof(deviceId, bundleId);
+
+      if (PID > 0) {
+        return PID;
+      }
+
+      await sleep(1000);
+    }
+
+    return NaN;
   }
 
   async deliverPayload(params) {

detox/src/devices/Device.js

@@ -19,8 +19,8 @@ class Device {
     return this._deviceId;
   }
 
-  get bundleId() {
-    return this._bundleId;
+  get processId() {
+    return this._processes[this._bundleId];
   }
 
   async prepare(params = {}) {

detox/src/devices/Device.test.js

@@ -72,11 +72,12 @@ describe('Device', () => {
     expect(device.id).toBe('mockDeviceId');
   });
 
-  it('should provide device.bundleId', async () => {
+  it('should provide device.processId', async () => {
     device = validDevice();
     device.deviceDriver.getBundleIdFromBinary.mockReturnValue('test.bundle');
-    await device.prepare();
-    expect(device.bundleId).toBe('test.bundle');
+    device.deviceDriver.launch.mockReturnValue('fakeId');
+    await device.prepare({ launchApp: true });
+    expect(device.processId).toBe('fakeId');
   });
 
   it(`prepare() with when reuse is enabled should not uninstall and install`, async () => {

detox/src/devices/EmulatorDriver.js

@@ -2,7 +2,9 @@ const _ = require('lodash');
 const path = require('path');
 const Emulator = require('./android/Emulator');
 const EmulatorTelnet = require('./android/EmulatorTelnet');
+const DetoxRuntimeError = require('../errors/DetoxRuntimeError');
 const Environment = require('../utils/environment');
+const sleep = require('../utils/sleep');
 const AndroidDriver = require('./AndroidDriver');
 const ini = require('ini');
 const fs = require('fs');
@@ -35,7 +37,7 @@ class EmulatorDriver extends AndroidDriver {
 
   async boot(deviceId) {
     await this.emulator.boot(deviceId);
-    await this.adb.waitForBootComplete(deviceId);
+    await this._waitForBootToComplete(deviceId);
   }
 
   async acquireFreeDevice(name) {
@@ -70,11 +72,30 @@ class EmulatorDriver extends AndroidDriver {
         throw new Error(`Got more than one device corresponding to the name: ${name}`);
     }
 
-    await this.adb.waitForBootComplete(adbName);
+    await this._waitForBootToComplete(adbName);
     await this.adb.unlockScreen(adbName);
     return adbName;
   }
 
+  async _waitForBootToComplete(deviceId) {
+    const start = Date.now();
+    const maxTimeToBoot = 10 * 60 * 1000;
+
+    while (Date.now() - start < maxTimeToBoot) {
+      const isBootComplete = await this.adb.isBootComplete(deviceId);
+
+      if (isBootComplete) {
+        return;
+      }
+
+      sleep(2000);
+    }
+
+    throw new DetoxRuntimeError({
+      message: `Failed to wait enough time for boot to complete on device: ${deviceId}`,
+    });
+  }
+
   async shutdown(deviceId) {
     const port = _.split(deviceId, '-')[1];
     const telnet = new EmulatorTelnet();