appium-android-driver 5.13.0 → 5.13.2

package/build/lib/commands/actions.js

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