appium-android-driver 5.14.7 → 6.0.1

package/lib/commands/actions.js

@@ -1,505 +1,392 @@
-import androidHelpers from '../android-helpers';
-import {fs, util, tempDir, imageUtil} from '@appium/support';
-import path from 'path';
+// @ts-check
+
+import {fs, tempDir, util, imageUtil} from '@appium/support';
 import B from 'bluebird';
+import path from 'path';
 import {exec} from 'teen_process';
+import {AndroidHelpers} from '../helpers';
 import {requireArgs} from '../utils';
+import {mixin} from './mixins';
 
 const swipeStepsPerSec = 28;
 const dragStepsPerSec = 40;
 
-const commands = {};
-const helpers = {};
-const extensions = {};
-
-commands.keyevent = async function keyevent(keycode, metastate = null) {
-  // TODO deprecate keyevent; currently wd only implements keyevent
-  this.log.warn('keyevent will be deprecated use pressKeyCode');
-  return await this.pressKeyCode(keycode, metastate);
-};
-
-commands.pressKeyCode = async function pressKeyCode(keycode, metastate = null) {
-  return await this.bootstrap.sendAction('pressKeyCode', {keycode, metastate});
-};
-
-commands.longPressKeyCode = async function longPressKeyCode(keycode, metastate = null) {
-  return await this.bootstrap.sendAction('longPressKeyCode', {keycode, metastate});
-};
-
-commands.getOrientation = async function getOrientation() {
-  let params = {
-    naturalOrientation: !!this.opts.androidNaturalOrientation,
-  };
-  let orientation = await this.bootstrap.sendAction('orientation', params);
-  return orientation.toUpperCase();
-};
-
-commands.setOrientation = async function setOrientation(orientation) {
-  orientation = orientation.toUpperCase();
-  let params = {
-    orientation,
-    naturalOrientation: !!this.opts.androidNaturalOrientation,
-  };
-  return await this.bootstrap.sendAction('orientation', params);
-};
-
-commands.fakeFlick = async function fakeFlick(xSpeed, ySpeed) {
-  return await this.bootstrap.sendAction('flick', {xSpeed, ySpeed});
-};
-
-commands.fakeFlickElement = async function fakeFlickElement(elementId, xoffset, yoffset, speed) {
-  let params = {xoffset, yoffset, speed, elementId};
-  return await this.bootstrap.sendAction('element:flick', params);
-};
-
-commands.swipe = async function swipe(startX, startY, endX, endY, duration, touchCount, elId) {
-  if (startX === 'null') {
-    startX = 0.5;
-  }
-  if (startY === 'null') {
-    startY = 0.5;
-  }
-  let swipeOpts = {startX, startY, endX, endY, steps: Math.round(duration * swipeStepsPerSec)};
-  // going the long way and checking for undefined and null since
-  // we can't be assured `elId` is a string and not an int
-  if (util.hasValue(elId)) {
-    swipeOpts.elementId = elId;
-  }
-  return await this.doSwipe(swipeOpts);
-};
-
-commands.doSwipe = async function doSwipe(swipeOpts) {
-  if (util.hasValue(swipeOpts.elementId)) {
-    return await this.bootstrap.sendAction('element:swipe', swipeOpts);
-  } else {
-    return await this.bootstrap.sendAction('swipe', swipeOpts);
-  }
-};
-
-commands.pinchClose = async function pinchClose(
-  startX,
-  startY,
-  endX,
-  endY,
-  duration,
-  percent,
-  steps,
-  elId
-) {
-  let pinchOpts = {
-    direction: 'in',
-    elementId: elId,
-    percent,
-    steps,
-  };
-  return await this.bootstrap.sendAction('element:pinch', pinchOpts);
-};
-
-commands.pinchOpen = async function pinchOpen(
-  startX,
-  startY,
-  endX,
-  endY,
-  duration,
-  percent,
-  steps,
-  elId
-) {
-  let pinchOpts = {direction: 'out', elementId: elId, percent, steps};
-  return await this.bootstrap.sendAction('element:pinch', pinchOpts);
-};
-
-commands.flick = async function flick(element, xSpeed, ySpeed, xOffset, yOffset, speed) {
-  if (element) {
-    await this.fakeFlickElement(element, xOffset, yOffset, speed);
-  } else {
-    await this.fakeFlick(xSpeed, ySpeed);
-  }
-};
-
-commands.drag = async function drag(
-  startX,
-  startY,
-  endX,
-  endY,
-  duration,
-  touchCount,
-  elementId,
-  destElId
-) {
-  let dragOpts = {
-    elementId,
-    destElId,
-    startX,
-    startY,
-    endX,
-    endY,
-    steps: Math.round(duration * dragStepsPerSec),
-  };
-  return await this.doDrag(dragOpts);
-};
-
-commands.doDrag = async function doDrag(dragOpts) {
-  if (util.hasValue(dragOpts.elementId)) {
-    return await this.bootstrap.sendAction('element:drag', dragOpts);
-  } else {
-    return await this.bootstrap.sendAction('drag', dragOpts);
-  }
-};
-
-/**
- * @typedef {Object} LockOptions
- * @property {number?} seconds The number to keep the locked.
- * 0 or empty value will keep the device locked.
- */
-
-/**
- * Lock the device (and optionally unlock it after a certain amount of time).
-
- * @param {LockOptions} opts
- * @throws {Error} if lock or unlock operation fails
- */
-
-commands.mobileLock = async function mobileLock(opts = {}) {
-  const {seconds} = opts;
-  return await this.lock(seconds);
-};
-
-commands.lock = async function lock(seconds) {
-  await this.adb.lock();
-  if (isNaN(seconds)) {
-    return;
-  }
-
-  const floatSeconds = parseFloat(seconds);
-  if (floatSeconds <= 0) {
-    return;
-  }
-  await B.delay(1000 * floatSeconds);
-  await this.unlock();
-};
-
-commands.isLocked = async function isLocked() {
-  return await this.adb.isScreenLocked();
-};
-
-commands.unlock = async function unlock() {
-  return await androidHelpers.unlock(this, this.adb, this.caps);
-};
-
-commands.openNotifications = async function openNotifications() {
-  return await this.bootstrap.sendAction('openNotification');
-};
-
-commands.setLocation = async function setLocation(latitude, longitude) {
-  return await this.adb.sendTelnetCommand(`geo fix ${longitude} ${latitude}`);
-};
-
-commands.fingerprint = async function fingerprint(fingerprintId) {
-  if (!this.isEmulator()) {
-    this.log.errorAndThrow('fingerprint method is only available for emulators');
-  }
-  await this.adb.fingerprint(fingerprintId);
-};
-
-/**
- * @typedef {Object} FingerprintOpts
- * @param {string|number} fingerprintId The value is the finger_id for the finger that
- * was "scanned". It is a unique integer that you assign for each virtual fingerprint.
- * When the app is running you can run this same command each time the
- * emulator prompts you for a fingerprint, you can run the adb command and pass it
- * the finger_id to simulate the fingerprint scan.
- */
-
 /**
- * Emulate fingerprint on Android Emulator.
- * Only works on API 23+
- *
- * @param {FingerprintOpts} opts
+ * @type {import('./mixins').ActionsMixin & ThisType<import('../driver').AndroidDriver>}
+ * @satisfies {import('@appium/types').ExternalDriver}
  */
-commands.mobileFingerprint = async function mobileFingerprint(opts = {}) {
-  const {fingerprintId} = requireArgs('fingerprintId', opts);
-  await this.fingerprint(fingerprintId);
-};
-
-commands.sendSMS = async function sendSMS(phoneNumber, message) {
-  if (!this.isEmulator()) {
-    this.log.errorAndThrow('sendSMS method is only available for emulators');
-  }
-  await this.adb.sendSMS(phoneNumber, message);
-};
+const ActionsMixin = {
+  async keyevent(keycode, metastate) {
+    // TODO deprecate keyevent; currently wd only implements keyevent
+    this.log.warn('keyevent will be deprecated use pressKeyCode');
+    return await this.pressKeyCode(keycode, metastate);
+  },
+
+  async pressKeyCode(keycode, metastate) {
+    return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction('pressKeyCode', {
+      keycode,
+      metastate: metastate ?? null,
+    });
+  },
+
+  async longPressKeyCode(keycode, metastate) {
+    return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction('longPressKeyCode', {
+      keycode,
+      metastate: metastate ?? null,
+    });
+  },
+
+  async getOrientation() {
+    let params = {
+      naturalOrientation: !!this.opts.androidNaturalOrientation,
+    };
+    let orientation = await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction(
+      'orientation',
+      params
+    );
+    return orientation.toUpperCase();
+  },
+
+  async setOrientation(orientation) {
+    let params = {
+      orientation: orientation.toUpperCase(),
+      naturalOrientation: !!this.opts.androidNaturalOrientation,
+    };
+    return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction('orientation', params);
+  },
+
+  async fakeFlick(xSpeed, ySpeed) {
+    return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction('flick', {
+      xSpeed,
+      ySpeed,
+    });
+  },
+
+  async fakeFlickElement(elementId, xoffset, yoffset, speed) {
+    let params = {xoffset, yoffset, speed, elementId};
+    return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction(
+      'element:flick',
+      params
+    );
+  },
+
+  async swipe(startX, startY, endX, endY, duration, touchCount, elId) {
+    if (startX === 'null') {
+      startX = 0.5;
+    }
+    if (startY === 'null') {
+      startY = 0.5;
+    }
+    /** @type {import('./types').SwipeOpts} */
+    const swipeOpts = {
+      startX,
+      startY,
+      endX,
+      endY,
+      steps: Math.round(duration * swipeStepsPerSec),
+    };
+    // going the long way and checking for undefined and null since
+    // we can't be assured `elId` is a string and not an int
+    if (util.hasValue(elId)) {
+      swipeOpts.elementId = elId;
+    }
+    return await this.doSwipe(swipeOpts);
+  },
+
+  async doSwipe(swipeOpts) {
+    if (util.hasValue(swipeOpts.elementId)) {
+      return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction(
+        'element:swipe',
+        swipeOpts
+      );
+    } else {
+      return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction('swipe', swipeOpts);
+    }
+  },
+
+  async pinchClose(startX, startY, endX, endY, duration, percent, steps, elId) {
+    let pinchOpts = {
+      direction: 'in',
+      elementId: elId,
+      percent,
+      steps,
+    };
+    return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction(
+      'element:pinch',
+      pinchOpts
+    );
+  },
+
+  async pinchOpen(startX, startY, endX, endY, duration, percent, steps, elId) {
+    let pinchOpts = {direction: 'out', elementId: elId, percent, steps};
+    return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction(
+      'element:pinch',
+      pinchOpts
+    );
+  },
+
+  async flick(element, xSpeed, ySpeed, xOffset, yOffset, speed) {
+    if (element) {
+      await this.fakeFlickElement(element, xOffset, yOffset, speed);
+    } else {
+      await this.fakeFlick(xSpeed, ySpeed);
+    }
+  },
+
+  async drag(startX, startY, endX, endY, duration, touchCount, elementId, destElId) {
+    let dragOpts = {
+      elementId,
+      destElId,
+      startX,
+      startY,
+      endX,
+      endY,
+      steps: Math.round(duration * dragStepsPerSec),
+    };
+    return await this.doDrag(dragOpts);
+  },
+
+  async doDrag(dragOpts) {
+    if (util.hasValue(dragOpts.elementId)) {
+      return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction(
+        'element:drag',
+        dragOpts
+      );
+    } else {
+      return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction('drag', dragOpts);
+    }
+  },
 
-/**
- * @typedef {Object} SendSmsOptions
- * @property {string} phoneNumber The phone number to send SMS to
- * @property {string} message The message payload
- */
+  async mobileLock(opts = {}) {
+    const {seconds} = opts;
+    return await this.lock(seconds);
+  },
 
-/**
- * Emulate sending an SMS to the given phone number.
- * Only works on emulators.
- *
- * @param {SendSmsOptions} opts
- */
-commands.mobileSendSms = async function mobileSendSms(opts = {}) {
-  const {phoneNumber, message} = requireArgs(['phoneNumber', 'message'], opts);
-  await this.sendSMS(phoneNumber, message);
-};
+  async lock(seconds) {
+    await /** @type {ADB} */ (this.adb).lock();
+    if (Number.isNaN(seconds)) {
+      return;
+    }
 
-commands.gsmCall = async function gsmCall(phoneNumber, action) {
-  if (!this.isEmulator()) {
-    this.log.errorAndThrow('gsmCall method is only available for emulators');
-  }
-  await this.adb.gsmCall(phoneNumber, action);
-};
+    const floatSeconds = parseFloat(String(seconds));
+    if (floatSeconds <= 0) {
+      return;
+    }
+    await B.delay(1000 * floatSeconds);
+    await this.unlock();
+  },
 
-/**
- * @typedef {Object} GsmCallOptions
- * @property {string} phoneNumber The phone number to call to
- * @property {call|accept|cancel|hold} action One of possible actions to take
- */
+  async isLocked() {
+    return await /** @type {ADB} */ (this.adb).isScreenLocked();
+  },
 
-/**
- * Emulate a GSM call to the given phone number.
- * Only works on emulators.
- *
- * @param {GsmCallOptions} opts
- */
-commands.mobileGsmCall = async function mobileGsmCall(opts = {}) {
-  const {phoneNumber, action} = requireArgs(['phoneNumber', 'action'], opts);
-  await this.gsmCall(phoneNumber, action);
-};
+  async unlock() {
+    return await AndroidHelpers.unlock(this, /** @type {ADB} */ (this.adb), this.caps);
+  },
 
-commands.gsmSignal = async function gsmSignal(signalStrengh) {
-  if (!this.isEmulator()) {
-    this.log.errorAndThrow('gsmSignal method is only available for emulators');
-  }
-  await this.adb.gsmSignal(signalStrengh);
-};
+  async openNotifications() {
+    return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction('openNotification');
+  },
 
-/**
- * @typedef {Object} GsmSignalOptions
- * @property {0|1|2|3|4} strength One of possible signal strength values, where 4 is the best signal.
- */
+  async setLocation(latitude, longitude) {
+    await /** @type {ADB} */ (this.adb).sendTelnetCommand(`geo fix ${longitude} ${latitude}`);
+  },
 
-/**
- * Emulate GSM signal strength change event.
- * Only works on emulators.
- *
- * @param {GsmSignalOptions} opts
- */
-commands.mobileGsmSignal = async function mobileGsmSignal(opts = {}) {
-  const {strength} = requireArgs('strength', opts);
-  await this.gsmSignal(strength);
-};
+  async fingerprint(fingerprintId) {
+    if (!this.isEmulator()) {
+      this.log.errorAndThrow('fingerprint method is only available for emulators');
+    }
+    await /** @type {ADB} */ (this.adb).fingerprint(String(fingerprintId));
+  },
 
-commands.gsmVoice = async function gsmVoice(state) {
-  if (!this.isEmulator()) {
-    this.log.errorAndThrow('gsmVoice method is only available for emulators');
-  }
-  await this.adb.gsmVoice(state);
-};
+  async mobileFingerprint(opts) {
+    const {fingerprintId} = requireArgs('fingerprintId', opts);
+    await this.fingerprint(fingerprintId);
+  },
 
-/**
- * @typedef {Object} GsmVoiceOptions
- * @property {on|off} state
- */
+  async sendSMS(phoneNumber, message) {
+    if (!this.isEmulator()) {
+      this.log.errorAndThrow('sendSMS method is only available for emulators');
+    }
+    await /** @type {ADB} */ (this.adb).sendSMS(phoneNumber, message);
+  },
 
-/**
- * Emulate GSM voice state change event.
- * Only works on emulators.
- *
- * @param {GsmVoiceOptions} opts
- */
-commands.mobileGsmVoice = async function mobileGsmVoice(opts = {}) {
-  const {state} = requireArgs('state', opts);
-  await this.gsmVoice(state);
-};
+  async mobileSendSms(opts) {
+    const {phoneNumber, message} = requireArgs(['phoneNumber', 'message'], opts);
+    await this.sendSMS(phoneNumber, message);
+  },
 
-commands.powerAC = async function powerAC(state) {
-  if (!this.isEmulator()) {
-    this.log.errorAndThrow('powerAC method is only available for emulators');
-  }
-  await this.adb.powerAC(state);
-};
+  async gsmCall(phoneNumber, action) {
+    if (!this.isEmulator()) {
+      this.log.errorAndThrow('gsmCall method is only available for emulators');
+    }
+    await /** @type {ADB} */ (this.adb).gsmCall(phoneNumber, action);
+  },
 
-/**
- * @typedef {Object} PowerAcOptions
- * @property {on|off} state
- */
+  async mobileGsmCall(opts) {
+    const {phoneNumber, action} = requireArgs(['phoneNumber', 'action'], opts);
+    await this.gsmCall(phoneNumber, action);
+  },
 
-/**
- * Emulate AC power state change.
- * Only works on emulators.
- *
- * @param {GsmVoiceOptions} opts
- */
-commands.mobilePowerAc = async function mobilePowerAc(opts = {}) {
-  const {state} = requireArgs('state', opts);
-  await this.powerAC(state);
-};
+  async gsmSignal(signalStrengh) {
+    if (!this.isEmulator()) {
+      this.log.errorAndThrow('gsmSignal method is only available for emulators');
+    }
+    await /** @type {ADB} */ (this.adb).gsmSignal(signalStrengh);
+  },
 
-commands.powerCapacity = async function powerCapacity(batteryPercent) {
-  if (!this.isEmulator()) {
-    this.log.errorAndThrow('powerCapacity method is only available for emulators');
-  }
-  await this.adb.powerCapacity(batteryPercent);
-};
+  async mobileGsmSignal(opts) {
+    const {strength} = requireArgs('strength', opts);
+    await this.gsmSignal(strength);
+  },
 
-/**
- * @typedef {Object} PowerCapacityOptions
- * @property {number} percent - Percentage value in range [0, 100]
- */
+  async gsmVoice(state) {
+    if (!this.isEmulator()) {
+      this.log.errorAndThrow('gsmVoice method is only available for emulators');
+    }
+    await /** @type {ADB} */ (this.adb).gsmVoice(state);
+  },
 
-/**
- * Emulate power capacity change.
- * Only works on emulators.
- *
- * @param {PowerCapacityOptions} opts
- */
-commands.mobilePowerCapacity = async function mobilePowerCapacity(opts = {}) {
-  const {percent} = requireArgs('percent', opts);
-  await this.powerCapacity(percent);
-};
+  async mobileGsmVoice(opts) {
+    const {state} = requireArgs('state', opts);
+    await this.gsmVoice(state);
+  },
 
-commands.networkSpeed = async function networkSpeed(networkSpeed) {
-  if (!this.isEmulator()) {
-    this.log.errorAndThrow('networkSpeed method is only available for emulators');
-  }
-  await this.adb.networkSpeed(networkSpeed);
-};
+  async powerAC(state) {
+    if (!this.isEmulator()) {
+      this.log.errorAndThrow('powerAC method is only available for emulators');
+    }
+    await /** @type {ADB} */ (this.adb).powerAC(state);
+  },
 
-/**
- * @typedef {Object} NetworkSpeedOptions
- * @property {gsm|scsd|gprs|edge|umts|hsdpa|lte|evdo|full} speed
- */
+  async mobilePowerAc(opts) {
+    const {state} = requireArgs('state', opts);
+    await this.powerAC(state);
+  },
 
-/**
- * Emulate different network connection speed modes.
- * Only works on emulators.
- *
- * @param {NetworkSpeedOptions} opts
- */
-commands.mobileNetworkSpeed = async function mobileNetworkSpeed(opts = {}) {
-  const {speed} = requireArgs('speed', opts);
-  await this.networkSpeed(speed);
-};
+  async powerCapacity(batteryPercent) {
+    if (!this.isEmulator()) {
+      this.log.errorAndThrow('powerCapacity method is only available for emulators');
+    }
+    await /** @type {ADB} */ (this.adb).powerCapacity(batteryPercent);
+  },
 
-/**
- * Emulate sensors values on the connected emulator.
- *
- * @typedef {Object} Sensor
- * @property {string} sensorType - sensor type declared in adb.SENSORS
- * @property {string} value - value to set to the sensor
- *
- * @param {Object} Sensor
- * @throws {Error} - If sensorType is not defined
- * @throws {Error} - If value for the se sor is not defined
- * @throws {Error} - If deviceType is not an emulator
- */
-commands.sensorSet = async function sensorSet(sensor = {}) {
-  const {sensorType, value} = sensor;
-  if (!util.hasValue(sensorType)) {
-    this.log.errorAndThrow(`'sensorType' argument is required`);
-  }
-  if (!util.hasValue(value)) {
-    this.log.errorAndThrow(`'value' argument is required`);
-  }
-  if (!this.isEmulator()) {
-    this.log.errorAndThrow('sensorSet method is only available for emulators');
-  }
-  await this.adb.sensorSet(sensorType, value);
-};
+  async mobilePowerCapacity(opts) {
+    const {percent} = requireArgs('percent', opts);
+    await this.powerCapacity(percent);
+  },
 
-/**
- * @param {ADB} adb
- * @param {Object} opts
- * @returns {Promise<Buffer>}
- */
-helpers.getScreenshotDataWithAdbShell = async function getScreenshotDataWithAdbShell(adb, opts) {
-  const localFile = await tempDir.path({prefix: 'appium', suffix: '.png'});
-  if (await fs.exists(localFile)) {
-    await fs.unlink(localFile);
-  }
-  try {
-    const pngDir = opts.androidScreenshotPath || '/data/local/tmp/';
-    const png = path.posix.resolve(pngDir, 'screenshot.png');
-    await adb.shell(['/system/bin/rm', `${png};`, '/system/bin/screencap', '-p', png]);
-    if (!(await adb.fileSize(png))) {
-      throw new Error('The size of the taken screenshot equals to zero.');
+  async networkSpeed(networkSpeed) {
+    if (!this.isEmulator()) {
+      this.log.errorAndThrow('networkSpeed method is only available for emulators');
     }
-    await adb.pull(png, localFile);
-    return await fs.readFile(localFile);
-  } finally {
+    await /** @type {ADB} */ (this.adb).networkSpeed(networkSpeed);
+  },
+
+  async mobileNetworkSpeed(opts) {
+    const {speed} = requireArgs('speed', opts);
+    await this.networkSpeed(speed);
+  },
+
+  async sensorSet(opts) {
+    const {sensorType, value} = opts;
+    if (!util.hasValue(sensorType)) {
+      this.log.errorAndThrow(`'sensorType' argument is required`);
+    }
+    if (!util.hasValue(value)) {
+      this.log.errorAndThrow(`'value' argument is required`);
+    }
+    if (!this.isEmulator()) {
+      this.log.errorAndThrow('sensorSet method is only available for emulators');
+    }
+    await /** @type {ADB} */ (this.adb).sensorSet(sensorType, value);
+  },
+
+  async getScreenshotDataWithAdbShell(adb, opts) {
+    const localFile = await tempDir.path({prefix: 'appium', suffix: '.png'});
     if (await fs.exists(localFile)) {
       await fs.unlink(localFile);
     }
-  }
-};
-
-/**
- * @param {ADB} adb
- * @returns {Promise<Buffer>}
- */
-helpers.getScreenshotDataWithAdbExecOut = async function getScreenshotDataWithAdbExecOut(adb) {
-  const {stdout, stderr, code} = await exec(
-    adb.executable.path,
-    [...adb.executable.defaultArgs, 'exec-out', '/system/bin/screencap', '-p'],
-    {encoding: 'binary', isBuffer: true}
-  );
-  // if there is an error, throw
-  if (code || stderr.length) {
-    throw new Error(`Screenshot returned error, code: '${code}', stderr: '${stderr.toString()}'`);
-  }
-  // if we don't get anything at all, throw
-  if (!stdout.length) {
-    throw new Error('Screenshot returned no data');
-  }
-
-  return stdout;
-};
-
-commands.getScreenshot = async function getScreenshot() {
-  const apiLevel = await this.adb.getApiLevel();
-  let image = null;
-  if (apiLevel > 20) {
     try {
-      // This screenshoting approach is way faster, since it requires less external commands
-      // to be executed. Unfortunately, exec-out option is only supported by newer Android/SDK versions (5.0 and later)
-      image = await this.getScreenshotDataWithAdbExecOut(this.adb);
-    } catch (e) {
-      this.log.info(
-        `Cannot get screenshot data with 'adb exec-out' because of '${e.message}'. ` +
-          `Defaulting to 'adb shell' call`
-      );
+      const pngDir = opts.androidScreenshotPath || '/data/local/tmp/';
+      const png = path.posix.resolve(pngDir, 'screenshot.png');
+      await adb.shell(['/system/bin/rm', `${png};`, '/system/bin/screencap', '-p', png]);
+      if (!(await adb.fileSize(png))) {
+        throw new Error('The size of the taken screenshot equals to zero.');
+      }
+      await adb.pull(png, localFile);
+      return await fs.readFile(localFile);
+    } finally {
+      if (await fs.exists(localFile)) {
+        await fs.unlink(localFile);
+      }
     }
-  }
-  if (!image) {
-    try {
-      image = await this.getScreenshotDataWithAdbShell(this.adb, this.opts);
-    } catch (e) {
-      const err =
-        `Cannot get screenshot data because of '${e.message}'. ` +
-        `Make sure the 'LayoutParams.FLAG_SECURE' is not set for ` +
-        `the current view`;
-      this.log.errorAndThrow(err);
+  },
+
+  async getScreenshotDataWithAdbExecOut(adb) {
+    const {stdout, stderr, code} = await exec(
+      adb.executable.path,
+      [...adb.executable.defaultArgs, 'exec-out', '/system/bin/screencap', '-p'],
+      {encoding: 'binary', isBuffer: true}
+    );
+    // if there is an error, throw
+    if (code || stderr.length) {
+      throw new Error(`Screenshot returned error, code: '${code}', stderr: '${stderr.toString()}'`);
     }
-  }
-  if (apiLevel < 23) {
-    // Android bug 8433742 - rotate screenshot if screen is rotated
-    let screenOrientation = await this.adb.getScreenOrientation();
-    try {
-      image = await imageUtil
-        .requireSharp()(image)
-        .rotate(-90 * screenOrientation)
-        .toBuffer();
-    } catch (err) {
-      this.log.warn(`Could not rotate screenshot due to error: ${err}`);
+    // if we don't get anything at all, throw
+    if (!stdout.length) {
+      throw new Error('Screenshot returned no data');
     }
-  }
-  return image.toString('base64');
+
+    return stdout;
+  },
+
+  async getScreenshot() {
+    const apiLevel = await /** @type {ADB} */ (this.adb).getApiLevel();
+    let image = null;
+    if (apiLevel > 20) {
+      try {
+        // This screenshoting approach is way faster, since it requires less external commands
+        // to be executed. Unfortunately, exec-out option is only supported by newer Android/SDK versions (5.0 and later)
+        image = await this.getScreenshotDataWithAdbExecOut(/** @type {ADB} */ (this.adb));
+      } catch (e) {
+        this.log.info(
+          `Cannot get screenshot data with 'adb exec-out' because of '${
+            /** @type {Error} */ (e).message
+          }'. ` + `Defaulting to 'adb shell' call`
+        );
+      }
+    }
+    if (!image) {
+      try {
+        image = await this.getScreenshotDataWithAdbShell(/** @type {ADB} */ (this.adb), this.opts);
+      } catch (e) {
+        const err =
+          `Cannot get screenshot data because of '${/** @type {Error} */ (e).message}'. ` +
+          `Make sure the 'LayoutParams.FLAG_SECURE' is not set for ` +
+          `the current view`;
+        this.log.error(err);
+        throw new Error(err);
+      }
+    }
+    if (apiLevel < 23) {
+      // Android bug 8433742 - rotate screenshot if screen is rotated
+      let screenOrientation = await /** @type {ADB} */ (this.adb).getScreenOrientation();
+      try {
+        image = await imageUtil.requireSharp()(image).rotate(-90 * screenOrientation).toBuffer();
+      } catch (err) {
+        this.log.warn(`Could not rotate screenshot due to error: ${err}`);
+      }
+    }
+    return image.toString('base64');
+  },
 };
 
-Object.assign(extensions, commands, helpers);
-export {commands, helpers};
-export default extensions;
+mixin(ActionsMixin);
+
+export default ActionsMixin;
+
+/**
+ * @typedef {import('../bootstrap').AndroidBootstrap} AndroidBootstrap
+ * @typedef {import('appium-adb').ADB} ADB
+ */