appium-android-driver 5.14.7 → 6.0.1

package/lib/commands/recordscreen.js

@@ -1,11 +1,11 @@
+// @ts-check
+
+import {fs, net, system, tempDir, timing, util} from '@appium/support';
+import {waitForCondition} from 'asyncbox';
 import _ from 'lodash';
-import { waitForCondition } from 'asyncbox';
-import { util, fs, net, tempDir, system, timing } from '@appium/support';
-import { exec } from 'teen_process';
 import path from 'path';
-
-
-const commands = {};
+import {exec} from 'teen_process';
+import {mixin} from './mixins';
 
 const RETRY_PAUSE = 300;
 const RETRY_TIMEOUT = 5000;
@@ -18,12 +18,22 @@ const DEFAULT_EXT = '.mp4';
 const MIN_EMULATOR_API_LEVEL = 27;
 const FFMPEG_BINARY = `ffmpeg${system.isWindows() ? '.exe' : ''}`;
 
-async function uploadRecordedMedia (localFile, remotePath = null, uploadOptions = {}) {
+/**
+ *
+ * @param {string} localFile
+ * @param {string} [remotePath]
+ * @param {import('./types').StopScreenRecordingOpts} uploadOptions
+ * @returns {Promise<string>}
+ */
+async function uploadRecordedMedia(localFile, remotePath, uploadOptions = {}) {
   if (_.isEmpty(remotePath)) {
     return (await util.toInMemoryBase64(localFile)).toString();
   }
 
   const {user, pass, method, headers, fileFieldName, formFields} = uploadOptions;
+  /**
+   * @type {import('@appium/support').NetOptions & import('@appium/support').HttpUploadOptions}
+   */
   const options = {
     method: method || 'PUT',
     headers,
@@ -33,32 +43,42 @@ async function uploadRecordedMedia (localFile, remotePath = null, uploadOptions
   if (user && pass) {
     options.auth = {user, pass};
   }
-  await net.uploadFile(localFile, remotePath, options);
+  await net.uploadFile(localFile, /** @type {string} */ (remotePath), options);
   return '';
 }
 
-async function verifyScreenRecordIsSupported (adb, isEmulator) {
+/**
+ *
+ * @param {ADB} adb
+ * @param {boolean} isEmulator
+ */
+async function verifyScreenRecordIsSupported(adb, isEmulator) {
   const apiLevel = await adb.getApiLevel();
   if (isEmulator && apiLevel < MIN_EMULATOR_API_LEVEL) {
-    throw new Error(`Screen recording does not work on emulators running Android API level less than ${MIN_EMULATOR_API_LEVEL}`);
+    throw new Error(
+      `Screen recording does not work on emulators running Android API level less than ${MIN_EMULATOR_API_LEVEL}`
+    );
   }
   if (apiLevel < 19) {
-    throw new Error(`Screen recording not available on API Level ${apiLevel}. Minimum API Level is 19.`);
+    throw new Error(
+      `Screen recording not available on API Level ${apiLevel}. Minimum API Level is 19.`
+    );
   }
 }
 
-async function scheduleScreenRecord (adb, recordingProperties, log = null) {
+/**
+ *
+ * @param {ADB} adb
+ * @param {import('@appium/types').StringRecord} recordingProperties
+ * @param {import('@appium/types').AppiumLogger} [log]
+ * @returns {Promise<void>}
+ */
+async function scheduleScreenRecord(adb, recordingProperties, log) {
   if (recordingProperties.stopped) {
     return;
   }
 
-  const {
-    timer,
-    videoSize,
-    bitRate,
-    timeLimit,
-    bugReport,
-  } = recordingProperties;
+  const {timer, videoSize, bitRate, timeLimit, bugReport} = recordingProperties;
 
   let currentTimeLimit = MAX_RECORDING_TIME_SEC;
   if (util.hasValue(recordingProperties.currentTimeLimit)) {
@@ -88,16 +108,19 @@ async function scheduleScreenRecord (adb, recordingProperties, log = null) {
     }
 
     recordingProperties.currentTimeLimit = timeLimitInt - currentDuration;
-    const chunkDuration = recordingProperties.currentTimeLimit < MAX_RECORDING_TIME_SEC
-      ? recordingProperties.currentTimeLimit
-      : MAX_RECORDING_TIME_SEC;
-    log?.debug(`Starting the next ${chunkDuration}s-chunk ` +
-      `of screen recording in order to achieve ${timeLimitInt}s total duration`);
+    const chunkDuration =
+      recordingProperties.currentTimeLimit < MAX_RECORDING_TIME_SEC
+        ? recordingProperties.currentTimeLimit
+        : MAX_RECORDING_TIME_SEC;
+    log?.debug(
+      `Starting the next ${chunkDuration}s-chunk ` +
+        `of screen recording in order to achieve ${timeLimitInt}s total duration`
+    );
     (async () => {
       try {
         await scheduleScreenRecord(adb, recordingProperties, log);
       } catch (e) {
-        log?.error(e.stack);
+        log?.error(/** @type {Error} */ (e).stack);
         recordingProperties.stopped = true;
       }
     })();
@@ -105,39 +128,59 @@ async function scheduleScreenRecord (adb, recordingProperties, log = null) {
 
   await recordingProc.start(0);
   try {
-    await waitForCondition(async () => await adb.fileExists(pathOnDevice),
-      {waitMs: RETRY_TIMEOUT, intervalMs: RETRY_PAUSE});
+    await waitForCondition(async () => await adb.fileExists(pathOnDevice), {
+      waitMs: RETRY_TIMEOUT,
+      intervalMs: RETRY_PAUSE,
+    });
   } catch (e) {
-    throw new Error(`The expected screen record file '${pathOnDevice}' does not exist after ${RETRY_TIMEOUT}ms. ` +
-      `Is ${SCREENRECORD_BINARY} utility available and operational on the device under test?`);
+    throw new Error(
+      `The expected screen record file '${pathOnDevice}' does not exist after ${RETRY_TIMEOUT}ms. ` +
+        `Is ${SCREENRECORD_BINARY} utility available and operational on the device under test?`
+    );
   }
 
   recordingProperties.records.push(pathOnDevice);
   recordingProperties.recordingProcess = recordingProc;
 }
 
-async function mergeScreenRecords (mediaFiles, log = null) {
+/**
+ *
+ * @param {string[]} mediaFiles
+ * @param {import('@appium/types').AppiumLogger} [log]
+ * @returns {Promise<string>}
+ */
+async function mergeScreenRecords(mediaFiles, log) {
   try {
     await fs.which(FFMPEG_BINARY);
   } catch (e) {
-    throw new Error(`${FFMPEG_BINARY} utility is not available in PATH. Please install it from https://www.ffmpeg.org/`);
+    throw new Error(
+      `${FFMPEG_BINARY} utility is not available in PATH. Please install it from https://www.ffmpeg.org/`
+    );
   }
-  const configContent = mediaFiles
-    .map((x) => `file '${x}'`)
-    .join('\n');
+  const configContent = mediaFiles.map((x) => `file '${x}'`).join('\n');
   const configFile = path.resolve(path.dirname(mediaFiles[0]), 'config.txt');
   await fs.writeFile(configFile, configContent, 'utf8');
   log?.debug(`Generated ffmpeg merging config '${configFile}' with items:\n${configContent}`);
-  const result = path.resolve(path.dirname(mediaFiles[0]), `merge_${Math.floor(new Date())}${DEFAULT_EXT}`);
+  const result = path.resolve(
+    path.dirname(mediaFiles[0]),
+    `merge_${Math.floor(+new Date())}${DEFAULT_EXT}`
+  );
   const args = ['-safe', '0', '-f', 'concat', '-i', configFile, '-c', 'copy', result];
-  log?.info(`Initiating screen records merging using the command '${FFMPEG_BINARY} ${args.join(' ')}'`);
+  log?.info(
+    `Initiating screen records merging using the command '${FFMPEG_BINARY} ${args.join(' ')}'`
+  );
   await exec(FFMPEG_BINARY, args);
   return result;
 }
 
-async function terminateBackgroundScreenRecording (adb, force = true) {
-  const pids = (await adb.getPIDsByName(SCREENRECORD_BINARY))
-    .map((p) => `${p}`);
+/**
+ *
+ * @param {ADB} adb
+ * @param {boolean} force
+ * @returns {Promise<boolean>}
+ */
+async function terminateBackgroundScreenRecording(adb, force = true) {
+  const pids = (await adb.getPIDsByName(SCREENRECORD_BINARY)).map((p) => `${p}`);
   if (_.isEmpty(pids)) {
     return false;
   }
@@ -150,199 +193,159 @@ async function terminateBackgroundScreenRecording (adb, force = true) {
     });
     return true;
   } catch (err) {
-    throw new Error(`Unable to stop the background screen recording: ${err.message}`);
+    throw new Error(
+      `Unable to stop the background screen recording: ${/** @type {Error} */ (err).message}`
+    );
   }
 }
 
-
-/**
- * @typedef {Object} StartRecordingOptions
- *
- * @property {?string} remotePath - The path to the remote location, where the captured video should be uploaded.
- *                                  The following protocols are supported: http/https, ftp.
- *                                  Null or empty string value (the default setting) means the content of resulting
- *                                  file should be encoded as Base64 and passed as the endpount response value.
- *                                  An exception will be thrown if the generated media file is too big to
- *                                  fit into the available process memory.
- *                                  This option only has an effect if there is screen recording process in progreess
- *                                  and `forceRestart` parameter is not set to `true`.
- * @property {?string} user - The name of the user for the remote authentication. Only works if `remotePath` is provided.
- * @property {?string} pass - The password for the remote authentication. Only works if `remotePath` is provided.
- * @property {?string} method [PUT] - The http multipart upload method name. Only works if `remotePath` is provided.
- * @property {?Object} headers - Additional headers mapping for multipart http(s) uploads
- * @property {?string} fileFieldName [file] - The name of the form field, where the file content BLOB should be stored for
- *                                            http(s) uploads
- * @property {?Object|Array<Pair>} formFields - Additional form fields for multipart http(s) uploads
- * @property {?string} videoSize - The format is widthxheight.
- *                  The default value is the device's native display resolution (if supported),
- *                  1280x720 if not. For best results,
- *                  use a size supported by your device's Advanced Video Coding (AVC) encoder.
- *                  For example, "1280x720"
- * @property {?boolean} bugReport - Set it to `true` in order to display additional information on the video overlay,
- *                                  such as a timestamp, that is helpful in videos captured to illustrate bugs.
- *                                  This option is only supported since API level 27 (Android P).
- * @property {?string|number} timeLimit - The maximum recording time, in seconds. The default value is 180 (3 minutes).
- *                                        The maximum value is 1800 (30 minutes). If the passed value is greater than 180 then
- *                                        the algorithm will try to schedule multiple screen recording chunks and merge the
- *                                        resulting videos into a single media file using `ffmpeg` utility.
- *                                        If the utility is not available in PATH then the most recent screen recording chunk is
- *                                        going to be returned.
- * @property {?string|number} bitRate - The video bit rate for the video, in bits per second.
- *                The default value is 4000000 (4 Mbit/s). You can increase the bit rate to improve video quality,
- *                but doing so results in larger movie files.
- * @property {?boolean} forceRestart - Whether to try to catch and upload/return the currently running screen recording
- *                                     (`false`, the default setting) or ignore the result of it and start a new recording
- *                                     immediately (`true`).
- */
-
 /**
- * Record the display of a real devices running Android 4.4 (API level 19) and higher.
- * Emulators are supported since API level 27 (Android P).
- * It records screen activity to an MPEG-4 file. Audio is not recorded with the video file.
- * If screen recording has been already started then the command will stop it forcefully and start a new one.
- * The previously recorded video file will be deleted.
- *
- * @param {?StartRecordingOptions} options - The available options.
- * @returns {string} Base64-encoded content of the recorded media file if
- *                   any screen recording is currently running or an empty string.
- * @throws {Error} If screen recording has failed to start or is not supported on the device under test.
+ * @type {import('./mixins').RecordScreenMixin & ThisType<import('../driver').AndroidDriver>}
+ * @satisfies {import('@appium/types').ExternalDriver}
  */
-commands.startRecordingScreen = async function startRecordingScreen (options = {}) {
-  await verifyScreenRecordIsSupported(this.adb, this.isEmulator());
-
-  let result = '';
-  const {videoSize, timeLimit = DEFAULT_RECORDING_TIME_SEC, bugReport, bitRate, forceRestart} = options;
-  if (!forceRestart) {
-    result = await this.stopRecordingScreen(options);
-  }
-
-  if (await terminateBackgroundScreenRecording(this.adb, true)) {
-    this.log.warn(`There were some ${SCREENRECORD_BINARY} process leftovers running ` +
-      `in the background. Make sure you stop screen recording each time after it is started, ` +
-      `otherwise the recorded media might quickly exceed all the free space on the device under test.`);
-  }
-
-  if (!_.isEmpty(this._screenRecordingProperties)) {
-    for (const record of (this._screenRecordingProperties.records || [])) {
-      await this.adb.rimraf(record);
+const RecordScreenMixin = {
+  async startRecordingScreen(options = {}) {
+    const adb = /** @type {ADB} */ (this.adb);
+    await verifyScreenRecordIsSupported(adb, this.isEmulator());
+
+    let result = '';
+    const {
+      videoSize,
+      timeLimit = DEFAULT_RECORDING_TIME_SEC,
+      bugReport,
+      bitRate,
+      forceRestart,
+    } = options;
+    if (!forceRestart) {
+      result = await this.stopRecordingScreen(options);
     }
-    this._screenRecordingProperties = null;
-  }
 
-  const timeout = parseFloat(timeLimit);
-  if (isNaN(timeout) || timeout > MAX_TIME_SEC || timeout <= 0) {
-    throw new Error(`The timeLimit value must be in range [1, ${MAX_TIME_SEC}] seconds. ` +
-      `The value of '${timeLimit}' has been passed instead.`);
-  }
-
-  this._screenRecordingProperties = {
-    timer: new timing.Timer().start(),
-    videoSize,
-    timeLimit,
-    currentTimeLimit: timeLimit,
-    bitRate,
-    bugReport,
-    records: [],
-    recordingProcess: null,
-    stopped: false,
-  };
-  await scheduleScreenRecord(this.adb, this._screenRecordingProperties, this.log);
-  return result;
-};
+    if (await terminateBackgroundScreenRecording(adb, true)) {
+      this.log.warn(
+        `There were some ${SCREENRECORD_BINARY} process leftovers running ` +
+          `in the background. Make sure you stop screen recording each time after it is started, ` +
+          `otherwise the recorded media might quickly exceed all the free space on the device under test.`
+      );
+    }
 
-/**
- * @typedef {Object} StopRecordingOptions
- *
- * @property {?string} remotePath - The path to the remote location, where the resulting video should be uploaded.
- *                                  The following protocols are supported: http/https, ftp.
- *                                  Null or empty string value (the default setting) means the content of resulting
- *                                  file should be encoded as Base64 and passed as the endpount response value.
- *                                  An exception will be thrown if the generated media file is too big to
- *                                  fit into the available process memory.
- * @property {?string} user - The name of the user for the remote authentication.
- * @property {?string} pass - The password for the remote authentication.
- * @property {?string} method - The http multipart upload method name. The 'PUT' one is used by default.
- * @property {?Object} headers - Additional headers mapping for multipart http(s) uploads
- * @property {?string} fileFieldName [file] - The name of the form field, where the file content BLOB should be stored for
- *                                            http(s) uploads
- * @property {?Object|Array<Pair>} formFields - Additional form fields for multipart http(s) uploads
- */
+    if (!_.isEmpty(this._screenRecordingProperties)) {
+      // XXX: this doesn't need to be done in serial, does it?
+      for (const record of this._screenRecordingProperties.records || []) {
+        await /** @type {ADB} */ (this.adb).rimraf(record);
+      }
+      this._screenRecordingProperties = undefined;
+    }
 
-/**
- * Stop recording the screen.
- * If no screen recording has been started before then the method returns an empty string.
- *
- * @param {?StopRecordingOptions} options - The available options.
- * @returns {string} Base64-encoded content of the recorded media file if 'remotePath'
- *                   parameter is falsy or an empty string.
- * @throws {Error} If there was an error while getting the name of a media file
- *                 or the file content cannot be uploaded to the remote location
- *                 or screen recording is not supported on the device under test.
- */
-commands.stopRecordingScreen = async function stopRecordingScreen (options = {}) {
-  await verifyScreenRecordIsSupported(this.adb, this.isEmulator());
+    const timeout = parseFloat(String(timeLimit));
+    if (isNaN(timeout) || timeout > MAX_TIME_SEC || timeout <= 0) {
+      throw new Error(
+        `The timeLimit value must be in range [1, ${MAX_TIME_SEC}] seconds. ` +
+          `The value of '${timeLimit}' has been passed instead.`
+      );
+    }
 
-  if (!_.isEmpty(this._screenRecordingProperties)) {
-    this._screenRecordingProperties.stopped = true;
-  }
+    this._screenRecordingProperties = {
+      timer: new timing.Timer().start(),
+      videoSize,
+      timeLimit,
+      currentTimeLimit: timeLimit,
+      bitRate,
+      bugReport,
+      records: [],
+      recordingProcess: null,
+      stopped: false,
+    };
+    await scheduleScreenRecord(adb, this._screenRecordingProperties, this.log);
+    return result;
+  },
+
+  async stopRecordingScreen(options = {}) {
+    const adb = /** @type {ADB} */ (this.adb);
+    await verifyScreenRecordIsSupported(adb, this.isEmulator());
 
-  try {
-    await terminateBackgroundScreenRecording(this.adb, false);
-  } catch (err) {
-    this.log.warn(err.message);
     if (!_.isEmpty(this._screenRecordingProperties)) {
-      this.log.warn('The resulting video might be corrupted');
+      this._screenRecordingProperties.stopped = true;
     }
-  }
 
-  if (_.isEmpty(this._screenRecordingProperties)) {
-    this.log.info(`Screen recording has not been previously started by Appium. There is nothing to stop`);
-    return '';
-  }
-
-  if (this._screenRecordingProperties.recordingProcess && this._screenRecordingProperties.recordingProcess.isRunning) {
     try {
-      await this._screenRecordingProperties.recordingProcess.stop('SIGINT', PROCESS_SHUTDOWN_TIMEOUT);
-    } catch (e) {
-      this.log.errorAndThrow(`Unable to stop screen recording within ${PROCESS_SHUTDOWN_TIMEOUT}ms`);
+      await terminateBackgroundScreenRecording(adb, false);
+    } catch (err) {
+      this.log.warn(/** @type {Error} */ (err).message);
+      if (!_.isEmpty(this._screenRecordingProperties)) {
+        this.log.warn('The resulting video might be corrupted');
+      }
     }
-    this._screenRecordingProperties.recordingProcess = null;
-  }
-
-  if (_.isEmpty(this._screenRecordingProperties.records)) {
-    this.log.errorAndThrow(`No screen recordings have been stored on the device so far. ` +
-      `Are you sure the ${SCREENRECORD_BINARY} utility works as expected?`);
-  }
 
-  const tmpRoot = await tempDir.openDir();
-  try {
-    const localRecords = [];
-    for (const pathOnDevice of this._screenRecordingProperties.records) {
-      localRecords.push(path.resolve(tmpRoot, path.posix.basename(pathOnDevice)));
-      await this.adb.pull(pathOnDevice, _.last(localRecords));
-      await this.adb.rimraf(pathOnDevice);
+    if (_.isEmpty(this._screenRecordingProperties)) {
+      this.log.info(
+        `Screen recording has not been previously started by Appium. There is nothing to stop`
+      );
+      return '';
     }
-    let resultFilePath = _.last(localRecords);
-    if (localRecords.length > 1) {
-      this.log.info(`Got ${localRecords.length} screen recordings. Trying to merge them`);
+
+    if (
+      this._screenRecordingProperties.recordingProcess &&
+      this._screenRecordingProperties.recordingProcess.isRunning
+    ) {
       try {
-        resultFilePath = await mergeScreenRecords(localRecords, this.log);
+        await this._screenRecordingProperties.recordingProcess.stop(
+          'SIGINT',
+          PROCESS_SHUTDOWN_TIMEOUT
+        );
       } catch (e) {
-        this.log.warn(`Cannot merge the recorded files. The most recent screen recording is going to be returned as the result. ` +
-          `Original error: ${e.message}`);
+        this.log.errorAndThrow(
+          `Unable to stop screen recording within ${PROCESS_SHUTDOWN_TIMEOUT}ms`
+        );
       }
+      this._screenRecordingProperties.recordingProcess = null;
     }
-    if (_.isEmpty(options.remotePath)) {
-      const {size} = await fs.stat(resultFilePath);
-      this.log.debug(`The size of the resulting screen recording is ${util.toReadableSizeString(size)}`);
+
+    if (_.isEmpty(this._screenRecordingProperties.records)) {
+      this.log.errorAndThrow(
+        `No screen recordings have been stored on the device so far. ` +
+          `Are you sure the ${SCREENRECORD_BINARY} utility works as expected?`
+      );
     }
-    return await uploadRecordedMedia(resultFilePath, options.remotePath, options);
-  } finally {
-    await fs.rimraf(tmpRoot);
-    this._screenRecordingProperties = null;
-  }
+
+    const tmpRoot = await tempDir.openDir();
+    try {
+      const localRecords = [];
+      for (const pathOnDevice of this._screenRecordingProperties.records) {
+        const relativePath = path.resolve(tmpRoot, path.posix.basename(pathOnDevice));
+        localRecords.push(relativePath);
+        await adb.pull(pathOnDevice, relativePath);
+        await adb.rimraf(pathOnDevice);
+      }
+      let resultFilePath = /** @type {string} */ (_.last(localRecords));
+      if (localRecords.length > 1) {
+        this.log.info(`Got ${localRecords.length} screen recordings. Trying to merge them`);
+        try {
+          resultFilePath = await mergeScreenRecords(localRecords, this.log);
+        } catch (e) {
+          this.log.warn(
+            `Cannot merge the recorded files. The most recent screen recording is going to be returned as the result. ` +
+              `Original error: ${/** @type {Error} */ (e).message}`
+          );
+        }
+      }
+      if (_.isEmpty(options.remotePath)) {
+        const {size} = await fs.stat(resultFilePath);
+        this.log.debug(
+          `The size of the resulting screen recording is ${util.toReadableSizeString(size)}`
+        );
+      }
+      return await uploadRecordedMedia(resultFilePath, options.remotePath, options);
+    } finally {
+      await fs.rimraf(tmpRoot);
+      this._screenRecordingProperties = undefined;
+    }
+  },
 };
 
+mixin(RecordScreenMixin);
+
+export default RecordScreenMixin;
 
-export { commands };
-export default commands;
+/**
+ * @typedef {import('appium-adb').ADB} ADB
+ */

package/lib/commands/shell.js

@@ -1,47 +1,58 @@
-import _ from 'lodash';
-import { exec } from 'teen_process';
-import { util } from '@appium/support';
-import { errors } from 'appium/driver';
-import { ADB_SHELL_FEATURE } from '../utils';
-
-const commands = {};
+// @ts-check
 
-commands.mobileShell = async function mobileShell (opts = {}) {
-  this.ensureFeatureEnabled(ADB_SHELL_FEATURE);
+import {util} from '@appium/support';
+import {errors} from 'appium/driver';
+import _ from 'lodash';
+import {exec} from 'teen_process';
+import {ADB_SHELL_FEATURE} from '../utils';
+import {mixin} from './mixins';
 
-  const {
-    command,
-    args = [],
-    timeout = 20000,
-    includeStderr,
-  } = opts;
+/**
+ * @type {import('./mixins').ShellMixin & ThisType<import('../driver').AndroidDriver>}
+ * @satisfies {import('@appium/types').ExternalDriver}
+ */
+const ShellMixin = {
+  async mobileShell(opts) {
+    this.ensureFeatureEnabled(ADB_SHELL_FEATURE);
+    const adb = /** @type {ADB} */ (this.adb);
+    const {
+      command,
+      args = /** @type {string[]} */ ([]),
+      timeout = 20000,
+      includeStderr,
+    } = opts ?? {};
 
-  if (!_.isString(command)) {
-    throw new errors.InvalidArgumentError(`The 'command' argument is mandatory`);
-  }
+    if (!_.isString(command)) {
+      throw new errors.InvalidArgumentError(`The 'command' argument is mandatory`);
+    }
 
-  const adbArgs = [
-    ...this.adb.executable.defaultArgs,
-    'shell',
-    command,
-    ...(_.isArray(args) ? args : [args])
-  ];
-  this.log.debug(`Running '${this.adb.executable.path} ${util.quote(adbArgs)}'`);
-  try {
-    const {stdout, stderr} = await exec(this.adb.executable.path, adbArgs, {timeout});
-    if (includeStderr) {
-      return {
-        stdout,
-        stderr
-      };
+    const adbArgs = [...adb.executable.defaultArgs, 'shell', command, ..._.castArray(args)];
+    this.log.debug(`Running '${adb.executable.path} ${util.quote(adbArgs)}'`);
+    try {
+      const {stdout, stderr} = await exec(adb.executable.path, adbArgs, {timeout});
+      if (includeStderr) {
+        return {
+          stdout,
+          stderr,
+        };
+      }
+      return stdout;
+    } catch (e) {
+      const err = /** @type {import('teen_process').ExecError} */ (e);
+      this.log.errorAndThrow(
+        `Cannot execute the '${command}' shell command. ` +
+          `Original error: ${err.message}. ` +
+          `StdOut: ${err.stdout}. StdErr: ${err.stderr}`
+      );
+      throw new Error(); // unreachable; for TS
     }
-    return stdout;
-  } catch (err) {
-    this.log.errorAndThrow(`Cannot execute the '${command}' shell command. ` +
-      `Original error: ${err.message}. ` +
-      `StdOut: ${err.stdout}. StdErr: ${err.stderr}`);
-  }
+  },
 };
 
-export { commands };
-export default commands;
+mixin(ShellMixin);
+
+export default ShellMixin;
+
+/**
+ * @typedef {import('appium-adb').ADB} ADB
+ */