appium-android-driver 5.14.7 → 6.0.0

package/build/lib/commands/actions.js

@@ -1,431 +1,332 @@
 "use strict";
+// @ts-check
 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 path_1 = __importDefault(require("path"));
 const teen_process_1 = require("teen_process");
+const helpers_1 = require("../helpers");
 const utils_1 = require("../utils");
+const mixins_1 = require("./mixins");
 const swipeStepsPerSec = 28;
 const dragStepsPerSec = 40;
-const commands = {};
-exports.commands = commands;
-const helpers = {};
-exports.helpers = 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 (support_1.util.hasValue(elId)) {
-        swipeOpts.elementId = elId;
-    }
-    return await this.doSwipe(swipeOpts);
-};
-commands.doSwipe = async function doSwipe(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);
-};
-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 (support_1.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 bluebird_1.default.delay(1000 * floatSeconds);
-    await this.unlock();
-};
-commands.isLocked = async function isLocked() {
-    return await this.adb.isScreenLocked();
-};
-commands.unlock = async function unlock() {
-    return await android_helpers_1.default.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.
+ * @type {import('./mixins').ActionsMixin & ThisType<import('../driver').AndroidDriver>}
+ * @satisfies {import('@appium/types').ExternalDriver}
  */
-/**
- * Emulate fingerprint on Android Emulator.
- * Only works on API 23+
- *
- * @param {FingerprintOpts} opts
- */
-commands.mobileFingerprint = async function mobileFingerprint(opts = {}) {
-    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);
-};
-/**
- * @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_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);
-};
-/**
- * @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_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);
-};
-/**
- * @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_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);
-};
-/**
- * @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_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);
-};
-/**
- * @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_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);
-};
-/**
- * @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_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);
-};
-/**
- * @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_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_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<Buffer>}
- */
-helpers.getScreenshotDataWithAdbShell = async function getScreenshotDataWithAdbShell(adb, opts) {
-    const localFile = await support_1.tempDir.path({ prefix: 'appium', suffix: '.png' });
-    if (await support_1.fs.exists(localFile)) {
-        await support_1.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.');
+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 (support_1.util.hasValue(elId)) {
+            swipeOpts.elementId = elId;
+        }
+        return await this.doSwipe(swipeOpts);
+    },
+    async doSwipe(swipeOpts) {
+        if (support_1.util.hasValue(swipeOpts.elementId)) {
+            return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction('element:swipe', swipeOpts);
+        }
+        else {
+            return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction('swipe', swipeOpts);
         }
-        await adb.pull(png, localFile);
-        return await support_1.fs.readFile(localFile);
-    }
-    finally {
+    },
+    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 (support_1.util.hasValue(dragOpts.elementId)) {
+            return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction('element:drag', dragOpts);
+        }
+        else {
+            return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction('drag', dragOpts);
+        }
+    },
+    async mobileLock(opts = {}) {
+        const { seconds } = opts;
+        return await this.lock(seconds);
+    },
+    async lock(seconds) {
+        await /** @type {ADB} */ (this.adb).lock();
+        if (Number.isNaN(seconds)) {
+            return;
+        }
+        const floatSeconds = parseFloat(String(seconds));
+        if (floatSeconds <= 0) {
+            return;
+        }
+        await bluebird_1.default.delay(1000 * floatSeconds);
+        await this.unlock();
+    },
+    async isLocked() {
+        return await /** @type {ADB} */ (this.adb).isScreenLocked();
+    },
+    async unlock() {
+        return await helpers_1.AndroidHelpers.unlock(this, /** @type {ADB} */ (this.adb), this.caps);
+    },
+    async openNotifications() {
+        return await /** @type {AndroidBootstrap} */ (this.bootstrap).sendAction('openNotification');
+    },
+    async setLocation(latitude, longitude) {
+        await /** @type {ADB} */ (this.adb).sendTelnetCommand(`geo fix ${longitude} ${latitude}`);
+    },
+    async fingerprint(fingerprintId) {
+        if (!this.isEmulator()) {
+            this.log.errorAndThrow('fingerprint method is only available for emulators');
+        }
+        await /** @type {ADB} */ (this.adb).fingerprint(String(fingerprintId));
+    },
+    async mobileFingerprint(opts) {
+        const { fingerprintId } = (0, utils_1.requireArgs)('fingerprintId', opts);
+        await this.fingerprint(fingerprintId);
+    },
+    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);
+    },
+    async mobileSendSms(opts) {
+        const { phoneNumber, message } = (0, utils_1.requireArgs)(['phoneNumber', 'message'], opts);
+        await this.sendSMS(phoneNumber, message);
+    },
+    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);
+    },
+    async mobileGsmCall(opts) {
+        const { phoneNumber, action } = (0, utils_1.requireArgs)(['phoneNumber', 'action'], opts);
+        await this.gsmCall(phoneNumber, action);
+    },
+    async gsmSignal(signalStrengh) {
+        if (!this.isEmulator()) {
+            this.log.errorAndThrow('gsmSignal method is only available for emulators');
+        }
+        await /** @type {ADB} */ (this.adb).gsmSignal(signalStrengh);
+    },
+    async mobileGsmSignal(opts) {
+        const { strength } = (0, utils_1.requireArgs)('strength', opts);
+        await this.gsmSignal(strength);
+    },
+    async gsmVoice(state) {
+        if (!this.isEmulator()) {
+            this.log.errorAndThrow('gsmVoice method is only available for emulators');
+        }
+        await /** @type {ADB} */ (this.adb).gsmVoice(state);
+    },
+    async mobileGsmVoice(opts) {
+        const { state } = (0, utils_1.requireArgs)('state', opts);
+        await this.gsmVoice(state);
+    },
+    async powerAC(state) {
+        if (!this.isEmulator()) {
+            this.log.errorAndThrow('powerAC method is only available for emulators');
+        }
+        await /** @type {ADB} */ (this.adb).powerAC(state);
+    },
+    async mobilePowerAc(opts) {
+        const { state } = (0, utils_1.requireArgs)('state', opts);
+        await this.powerAC(state);
+    },
+    async powerCapacity(batteryPercent) {
+        if (!this.isEmulator()) {
+            this.log.errorAndThrow('powerCapacity method is only available for emulators');
+        }
+        await /** @type {ADB} */ (this.adb).powerCapacity(batteryPercent);
+    },
+    async mobilePowerCapacity(opts) {
+        const { percent } = (0, utils_1.requireArgs)('percent', opts);
+        await this.powerCapacity(percent);
+    },
+    async networkSpeed(networkSpeed) {
+        if (!this.isEmulator()) {
+            this.log.errorAndThrow('networkSpeed method is only available for emulators');
+        }
+        await /** @type {ADB} */ (this.adb).networkSpeed(networkSpeed);
+    },
+    async mobileNetworkSpeed(opts) {
+        const { speed } = (0, utils_1.requireArgs)('speed', opts);
+        await this.networkSpeed(speed);
+    },
+    async sensorSet(opts) {
+        const { sensorType, value } = opts;
+        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 /** @type {ADB} */ (this.adb).sensorSet(sensorType, value);
+    },
+    async getScreenshotDataWithAdbShell(adb, opts) {
+        const localFile = await support_1.tempDir.path({ prefix: 'appium', suffix: '.png' });
         if (await support_1.fs.exists(localFile)) {
             await support_1.fs.unlink(localFile);
         }
-    }
-};
-/**
- * @param {ADB} adb
- * @returns {Promise<Buffer>}
- */
-helpers.getScreenshotDataWithAdbExecOut = async function getScreenshotDataWithAdbExecOut(adb) {
-    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 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);
+            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 await support_1.fs.readFile(localFile);
         }
-        catch (e) {
-            this.log.info(`Cannot get screenshot data with 'adb exec-out' because of '${e.message}'. ` +
-                `Defaulting to 'adb shell' call`);
+        finally {
+            if (await support_1.fs.exists(localFile)) {
+                await support_1.fs.unlink(localFile);
+            }
         }
-    }
-    if (!image) {
-        try {
-            image = await this.getScreenshotDataWithAdbShell(this.adb, this.opts);
+    },
+    async getScreenshotDataWithAdbExecOut(adb) {
+        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()}'`);
         }
-        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 we don't get anything at all, throw
+        if (!stdout.length) {
+            throw new Error('Screenshot returned no data');
         }
-    }
-    if (apiLevel < 23) {
-        // Android bug 8433742 - rotate screenshot if screen is rotated
-        let screenOrientation = await this.adb.getScreenOrientation();
-        try {
-            image = await support_1.imageUtil
-                .requireSharp()(image)
-                .rotate(-90 * screenOrientation)
-                .toBuffer();
+        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`);
+            }
         }
-        catch (err) {
-            this.log.warn(`Could not rotate screenshot due to error: ${err}`);
+        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);
+            }
         }
-    }
-    return image.toString('base64');
+        if (apiLevel < 23) {
+            // Android bug 8433742 - rotate screenshot if screen is rotated
+            let screenOrientation = await /** @type {ADB} */ (this.adb).getScreenOrientation();
+            try {
+                image = await support_1.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);
-exports.default = extensions;
+(0, mixins_1.mixin)(ActionsMixin);
+exports.default = ActionsMixin;
+/**
+ * @typedef {import('../bootstrap').AndroidBootstrap} AndroidBootstrap
+ * @typedef {import('appium-adb').ADB} ADB
+ */
 //# sourceMappingURL=actions.js.map