appium-android-driver 9.15.0 → 10.0.0

package/lib/commands/intent.js

@@ -75,11 +75,52 @@ export async function startActivity(
 
 /**
  * @this {import('../driver').AndroidDriver}
- * @param {import('./types').StartActivityOpts} [opts={}]
+ * @param {boolean} [wait] Set it to `true` if you want to block the method call
+ * until the activity manager's process returns the control to the system.
+ * false by default.
+ * @param {boolean} [stop] Set it to `true` to force stop the target
+ * app before starting the activity
+ * false by default.
+ * @param {string | number} [windowingMode] The windowing mode to launch the activity into.
+ * Check
+ * https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/app/WindowConfiguration.java
+ * for more details on possible windowing modes (constants starting with
+ * `WINDOWING_MODE_`).
+ * @param {string | number} [activityType] The activity type to launch the activity as.
+ * Check https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/app/WindowConfiguration.java
+ * for more details on possible activity types (constants starting with `ACTIVITY_TYPE_`).
+ * @param {number | string} [display] The display identifier to launch the activity into.
+ * @param {string} [user]
+ * @param {string} [intent]
+ * @param {string} [action]
+ * @param {string} [pkg]
+ * @param {string} [uri]
+ * @param {string} [mimeType]
+ * @param {string} [identifier]
+ * @param {string} [component]
+ * @param {string | string[]} [categories]
+ * @param {string[][]} [extras]
+ * @param {string} [flags]
  * @returns {Promise<string>}
  */
-export async function mobileStartActivity(opts = {}) {
-  const {user, wait, stop, windowingMode, activityType, display} = opts;
+export async function mobileStartActivity(
+  wait,
+  stop,
+  windowingMode,
+  activityType,
+  display,
+  user,
+  intent,
+  action,
+  pkg,
+  uri,
+  mimeType,
+  identifier,
+  component,
+  categories,
+  extras,
+  flags,
+) {
   const cmd = [
     'am',
     (await this.adb.getApiLevel()) < API_LEVEL_ANDROID_8 ? 'start' : 'start-activity',
@@ -102,17 +143,55 @@ export async function mobileStartActivity(opts = {}) {
   if (!_.isNil(display)) {
     cmd.push('--display', String(display));
   }
-  cmd.push(...parseIntentSpec(opts));
+  cmd.push(...parseIntentSpec({
+    intent,
+    action,
+    package: pkg,
+    uri,
+    mimeType,
+    identifier,
+    component,
+    categories,
+    extras,
+    flags,
+  }));
   return await this.adb.shell(cmd);
 }
 
 /**
  * @this {import('../driver').AndroidDriver}
- * @param {import('./types').BroadcastOpts} [opts={}]
+ * @param {string | number} [user] The user ID for which the broadcast is sent.
+ * The `current` alias assumes the current user ID.
+ * `all` by default.
+ * @param {string} [receiverPermission] Require receiver to hold the given permission.
+ * @param {boolean} [allowBackgroundActivityStarts] Whether the receiver may start activities even if in the background.
+ * @param {string} [intent]
+ * @param {string} [action]
+ * @param {string} [pkg]
+ * @param {string} [uri]
+ * @param {string} [mimeType]
+ * @param {string} [identifier]
+ * @param {string} [component]
+ * @param {string | string[]} [categories]
+ * @param {string[][]} [extras]
+ * @param {string} [flags]
  * @returns {Promise<string>}
  */
-export async function mobileBroadcast(opts = {}) {
-  const {user, receiverPermission, allowBackgroundActivityStarts} = opts;
+export async function mobileBroadcast(
+  receiverPermission,
+  allowBackgroundActivityStarts,
+  user,
+  intent,
+  action,
+  pkg,
+  uri,
+  mimeType,
+  identifier,
+  component,
+  categories,
+  extras,
+  flags,
+) {
   const cmd = ['am', 'broadcast'];
   if (!_.isNil(user)) {
     cmd.push('--user', String(user));
@@ -123,17 +202,53 @@ export async function mobileBroadcast(opts = {}) {
   if (allowBackgroundActivityStarts) {
     cmd.push('--allow-background-activity-starts');
   }
-  cmd.push(...parseIntentSpec(opts));
+  cmd.push(...parseIntentSpec({
+    intent,
+    action,
+    package: pkg,
+    uri,
+    mimeType,
+    identifier,
+    component,
+    categories,
+    extras,
+    flags,
+  }));
   return await this.adb.shell(cmd);
 }
 
 /**
  * @this {import('../driver').AndroidDriver}
- * @param {import('./types').StartServiceOpts} [opts={}]
+ * @param {boolean} [foreground] Set it to `true` if your service must be started as foreground service.
+ * This option is ignored if the API level of the device under test is below
+ *   26 (Android 8).
+ * @param {string} [user]
+ * @param {string} [intent]
+ * @param {string} [action]
+ * @param {string} [pkg]
+ * @param {string} [uri]
+ * @param {string} [mimeType]
+ * @param {string} [identifier]
+ * @param {string} [component]
+ * @param {string | string[]} [categories]
+ * @param {string[][]} [extras]
+ * @param {string} [flags]
  * @returns {Promise<string>}
  */
-export async function mobileStartService(opts = {}) {
-  const {user, foreground} = opts;
+export async function mobileStartService(
+  foreground,
+  user,
+  intent,
+  action,
+  pkg,
+  uri,
+  mimeType,
+  identifier,
+  component,
+  categories,
+  extras,
+  flags,
+) {
   const cmd = ['am'];
   if ((await this.adb.getApiLevel()) < API_LEVEL_ANDROID_8) {
     cmd.push('startservice');
@@ -143,17 +258,49 @@ export async function mobileStartService(opts = {}) {
   if (!_.isNil(user)) {
     cmd.push('--user', String(user));
   }
-  cmd.push(...parseIntentSpec(opts));
+  cmd.push(...parseIntentSpec({
+    intent,
+    action,
+    package: pkg,
+    uri,
+    mimeType,
+    identifier,
+    component,
+    categories,
+    extras,
+    flags,
+  }));
   return await this.adb.shell(cmd);
 }
 
 /**
  * @this {import('../driver').AndroidDriver}
- * @param {import('./types').StopServiceOpts} [opts={}]
+ * @param {string} [user]
+ * @param {string} [intent]
+ * @param {string} [action]
+ * @param {string} [pkg]
+ * @param {string} [uri]
+ * @param {string} [mimeType]
+ * @param {string} [identifier]
+ * @param {string} [component]
+ * @param {string | string[]} [categories]
+ * @param {string[][]} [extras]
+ * @param {string} [flags]
  * @returns {Promise<string>}
  */
-export async function mobileStopService(opts = {}) {
-  const {user} = opts;
+export async function mobileStopService(
+  user,
+  intent,
+  action,
+  pkg,
+  uri,
+  mimeType,
+  identifier,
+  component,
+  categories,
+  extras,
+  flags,
+) {
   const cmd = [
     'am',
     (await this.adb.getApiLevel()) < API_LEVEL_ANDROID_8 ? 'stopservice' : 'stop-service',
@@ -161,7 +308,18 @@ export async function mobileStopService(opts = {}) {
   if (!_.isNil(user)) {
     cmd.push('--user', String(user));
   }
-  cmd.push(...parseIntentSpec(opts));
+  cmd.push(...parseIntentSpec({
+    intent,
+    action,
+    package: pkg,
+    uri,
+    mimeType,
+    identifier,
+    component,
+    categories,
+    extras,
+    flags,
+  }));
   try {
     return await this.adb.shell(cmd);
   } catch (e) {

package/lib/commands/keyboard.js

@@ -1,7 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import _ from 'lodash';
 import {errors} from 'appium/driver';
-import {requireArgs} from '../utils';
 import {UNICODE_IME, EMPTY_IME} from 'io.appium.settings';
 
 /**
@@ -80,11 +79,10 @@ export async function longPressKeyCode(keycode, metastate) {
 
 /**
  * @this {import('../driver').AndroidDriver}
- * @param {import('./types').PerformEditorActionOpts} opts
+ * @param {string | number} action
  * @returns {Promise<void>}
  */
-export async function mobilePerformEditorAction(opts) {
-  const {action} = requireArgs('action', opts);
+export async function mobilePerformEditorAction(action) {
   await this.settingsApp.performEditorAction(action);
 }
 

package/lib/commands/lock/exports.js

@@ -17,16 +17,6 @@ import {
 } from './helpers';
 import _ from 'lodash';
 
-/**
- * @this {AndroidDriver}
- * @param {import('../types').LockOpts} opts
- * @returns {Promise<void>}
- */
-export async function mobileLock(opts = {}) {
-  const {seconds} = opts;
-  return await this.lock(seconds);
-}
-
 /**
  * @this {AndroidDriver}
  * @param {number} [seconds]
@@ -64,11 +54,20 @@ export async function unlock() {
 
 /**
  * @this {AndroidDriver}
- * @param {import('../types').UnlockOptions} [opts={}]
+ * @param {string} [key] The unlock key. The value of this key depends on the actual unlock type and
+ * could be a pin/password/pattern value or a biometric finger id.
+ * If not provided then the corresponding value from session capabilities is
+ * used.
+ * @param {import('../types').UnlockType} [type] The unlock type.
+ * If not provided then the corresponding value from session capabilities is used.
+ * @param {string} [strategy] Setting it to 'uiautomator' will enforce the driver to avoid using special
+ * ADB shortcuts in order to speed up the unlock procedure.
+ * 'uiautomator' by default.
+ * @param {number} [timeoutMs] The maximum time in milliseconds to wait until the screen gets unlocked
+ * 2000ms byde fault.
  * @returns {Promise<void>}
  */
-export async function mobileUnlock(opts = {}) {
-  const {key, type, strategy, timeoutMs} = opts;
+export async function mobileUnlock(key, type, strategy, timeoutMs) {
   if (!key && !type) {
     await this.unlock();
   } else {

package/lib/commands/media-projection.js

@@ -10,13 +10,25 @@ const DEFAULT_FILENAME_FORMAT = 'YYYY-MM-DDTHH-mm-ss';
 
 /**
  * @this {import('../driver').AndroidDriver}
- * @param {import('./types').StartMediaProjectionRecordingOpts} [options={}]
+ * @param {string} [resolution] Maximum supported resolution on-device (Detected automatically by the app
+ * itself), which usually equals to Full HD 1920x1080 on most phones however
+ * you can change it to following supported resolutions as well: "1920x1080",
+ * "1280x720", "720x480", "320x240", "176x144".
+ * @param {'high' | 'normal' | 'low'} [priority] Recording thread priority.
+ * If you face performance drops during testing with recording enabled, you
+ * can reduce recording priority
+ * 'high' by default
+ * @param {number} [maxDurationSec] Maximum allowed duration is 15 minutes; you can increase it if your test
+ * takes longer than that. 900s by default.
+ * @param {string} [filename] You can type recording video file name as you want, but recording currently
+ * supports only "mp4" format so your filename must end with ".mp4". An
+ * invalid file name will fail to start the recording. If not provided then
+ * the current timestamp will be used as file name.
  * @returns {Promise<boolean>}
  */
-export async function mobileStartMediaProjectionRecording(options = {}) {
+export async function mobileStartMediaProjectionRecording(resolution, priority, maxDurationSec, filename) {
   await verifyMediaProjectionRecordingIsSupported(this.adb);
 
-  const {resolution, priority, maxDurationSec, filename} = options;
   const recorder = this.settingsApp.makeMediaProjectionRecorder();
   const fname = adjustMediaExtension(filename || moment().format(DEFAULT_FILENAME_FORMAT));
   const didStart = await recorder.start({
@@ -48,10 +60,34 @@ export async function mobileIsMediaProjectionRecordingRunning() {
 
 /**
  * @this {import('../driver').AndroidDriver}
- * @param {import('./types').StopMediaProjectionRecordingOpts} [options={}]
+ * @param {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 endpoont response value.
+ * An exception will be thrown if the generated media file is too big to fit
+ * into the available process memory.
+ * @param {string} [user] The name of the user for the remote authentication.
+ * @param {string} [pass] The password for the remote authentication.
+ * @param {import('@appium/types').HTTPMethod} [method] The http multipart upload method name.
+ * 'PUT' by default.
+ * @param {import('@appium/types').StringRecord} [headers] Additional headers mapping for multipart http(s) uploads
+ * @param {string} [fileFieldName] The name of the form field, where the file content BLOB should be stored
+ * for http(s) uploads. 'file' by default.
+ * @param {import('./types').FormFields} [formFields] Additional form fields for multipart http(s) uploads
+ * @param {number} [uploadTimeout] The actual media upload request timeout in milliseconds.
+ * Defaults to `@appium/support.net.DEFAULT_TIMEOUT_MS`
  * @returns {Promise<string>}
  */
-export async function mobileStopMediaProjectionRecording(options = {}) {
+export async function mobileStopMediaProjectionRecording(
+  remotePath,
+  user,
+  pass,
+  method,
+  headers,
+  fileFieldName,
+  formFields,
+  uploadTimeout,
+) {
   await verifyMediaProjectionRecordingIsSupported(this.adb);
 
   const recorder = this.settingsApp.makeMediaProjectionRecorder();
@@ -65,7 +101,6 @@ export async function mobileStopMediaProjectionRecording(options = {}) {
     throw new Error(`No recent media projection recording have been found. Did you start any?`);
   }
 
-  const {remotePath} = options;
   if (_.isEmpty(remotePath)) {
     const {size} = await fs.stat(recentRecordingPath);
     this.log.debug(
@@ -73,7 +108,15 @@ export async function mobileStopMediaProjectionRecording(options = {}) {
     );
   }
   try {
-    return await uploadRecordedMedia(recentRecordingPath, remotePath, options);
+    return await uploadRecordedMedia(recentRecordingPath, remotePath, {
+      user,
+      pass,
+      method,
+      headers,
+      fileFieldName,
+      formFields,
+      uploadTimeout,
+    });
   } finally {
     await fs.rimraf(path.dirname(recentRecordingPath));
   }
@@ -85,7 +128,7 @@ export async function mobileStopMediaProjectionRecording(options = {}) {
  *
  * @param {string} localFile
  * @param {string} [remotePath]
- * @param {import('./types').StopMediaProjectionRecordingOpts} uploadOptions
+ * @param {UploadOptions} uploadOptions
  * @returns
  */
 async function uploadRecordedMedia(localFile, remotePath, uploadOptions = {}) {
@@ -102,9 +145,6 @@ async function uploadRecordedMedia(localFile, remotePath, uploadOptions = {}) {
     formFields,
     uploadTimeout: timeout,
   } = uploadOptions;
-  /**
-   * @type {Omit<import('./types').StopMediaProjectionRecordingOpts, 'uploadTimeout'> & {auth?: {user: string, pass: string}, timeout?: number}}
-   */
   const options = {
     method: method || 'PUT',
     headers,
@@ -144,6 +184,17 @@ async function verifyMediaProjectionRecordingIsSupported(adb) {
 
 // #endregion
 
+/**
+ * @typedef {Object} UploadOptions
+ * @property {string} [user]
+ * @property {string} [pass]
+ * @property {import('@appium/types').HTTPMethod} [method]
+ * @property {import('@appium/types').StringRecord} [headers]
+ * @property {string} [fileFieldName]
+ * @property {import('./types').FormFields} [formFields]
+ * @property {number} [uploadTimeout]
+ */
+
 /**
  * @typedef {import('appium-adb').ADB} ADB
  */

package/lib/commands/memory.js

@@ -6,12 +6,12 @@ import {errors} from 'appium/driver';
  * for more details.
  *
  * @this {import('../driver').AndroidDriver}
- * @param {import('./types').SendTrimMemoryOpts} opts
+ * @param {string} pkg The package name to send the `trimMemory` event to
+ * @param {'COMPLETE' | 'MODERATE' | 'BACKGROUND' | 'UI_HIDDEN' | 'RUNNING_CRITICAL' | 'RUNNING_LOW' | 'RUNNING_MODERATE'} level The
+ * actual memory trim level to be sent
  * @returns {Promise<void>}
  */
-export async function mobileSendTrimMemory(opts) {
-  const {pkg, level} = opts;
-
+export async function mobileSendTrimMemory(pkg, level) {
   if (!pkg) {
     throw new errors.InvalidArgumentError(`The 'pkg' argument must be provided`);
   }

package/lib/commands/network.js

@@ -9,7 +9,7 @@ const DATA_MASK = 0b100;
 const WIFI_KEY_NAME = 'wifi';
 const DATA_KEY_NAME = 'data';
 const AIRPLANE_MODE_KEY_NAME = 'airplaneMode';
-const SUPPORTED_SERVICE_NAMES = /** @type {const} */ ([
+const SUPPORTED_SERVICE_NAMES = /** @type {import('./types').ServiceType[]} */ ([
   WIFI_KEY_NAME,
   DATA_KEY_NAME,
   AIRPLANE_MODE_KEY_NAME,
@@ -46,24 +46,28 @@ export async function isWifiOn() {
 /**
  * @since Android 12 (only real devices, emulators work in all APIs)
  * @this {import('../driver').AndroidDriver}
- * @param {import('./types').SetConnectivityOpts} [opts={}]
+ * @param {boolean} [wifi] Either to enable or disable Wi-Fi.
+ * An unset value means to not change the state for the given service.
+ * @param {boolean} [data] Either to enable or disable mobile data connection.
+ * An unset value means to not change the state for the given service.
+ * @param {boolean} [airplaneMode] Either to enable to disable the Airplane Mode
+ * An unset value means to not change the state for the given service.
  * @returns {Promise<void>}
  */
-export async function mobileSetConnectivity(opts = {}) {
-  const {wifi, data, airplaneMode} = opts;
+export async function mobileSetConnectivity(wifi, data, airplaneMode) {
   if (_.every([wifi, data, airplaneMode], _.isUndefined)) {
     throw new errors.InvalidArgumentError(
       `Either one of ${JSON.stringify(SUPPORTED_SERVICE_NAMES)} options must be provided`,
     );
   }
 
-  const currentState = await this.mobileGetConnectivity({
-    services: /** @type {import('./types').ServiceType[]} */ ([
+  const currentState = await this.mobileGetConnectivity(
+    /** @type {import('./types').ServiceType[]} */ ([
       ...(_.isUndefined(wifi) ? [] : [WIFI_KEY_NAME]),
       ...(_.isUndefined(data) ? [] : [DATA_KEY_NAME]),
       ...(_.isUndefined(airplaneMode) ? [] : [AIRPLANE_MODE_KEY_NAME]),
     ]),
-  });
+  );
   /** @type {(Promise<any>|(() => Promise<any>))[]} */
   const setters = [];
   if (!_.isUndefined(wifi) && currentState.wifi !== Boolean(wifi)) {
@@ -87,11 +91,11 @@ export async function mobileSetConnectivity(opts = {}) {
 
 /**
  * @this {import('../driver').AndroidDriver}
- * @param {import('./types').GetConnectivityOpts} [opts={}]
+ * @param {import('./types').ServiceType[] | import('./types').ServiceType} [services] one or more
+ * services to get the connectivity for.
  * @returns {Promise<import('./types').GetConnectivityResult>}
  */
-export async function mobileGetConnectivity(opts = {}) {
-  let {services = SUPPORTED_SERVICE_NAMES} = opts;
+export async function mobileGetConnectivity(services = SUPPORTED_SERVICE_NAMES) {
   const svcs = _.castArray(services);
   const unsupportedServices = _.difference(services, SUPPORTED_SERVICE_NAMES);
   if (!_.isEmpty(unsupportedServices)) {

package/lib/commands/nfc.js

@@ -10,13 +10,12 @@ const SUPPORTED_ACTIONS = /** @type {const} */ ({
  * Performs the requested action on the default NFC adapter
  *
  * @this {AndroidDriver}
- * @param {import('./types').NfcOptions} opts
+ * @param { 'enable' | 'disable'} action
  * @returns {Promise<void>}
  * @throws {Error} if the device under test has no default NFC adapter
  * or there was a failure while performing the action.
  */
-export async function mobileNfc(opts) {
-  const {action} = opts;
+export async function mobileNfc(action) {
   switch (action) {
     case SUPPORTED_ACTIONS.ENABLE:
       await this.adb.setNfcOn(true);

package/lib/commands/performance.js

@@ -1,7 +1,6 @@
 // @ts-check
 import {retryInterval} from 'asyncbox';
 import _ from 'lodash';
-import {requireArgs} from '../utils';
 
 export const NETWORK_KEYS = [
   [
@@ -121,11 +120,11 @@ export async function getPerformanceData(packageName, dataType, retries = 2) {
  * - cpuinfo: [[user, kernel], [0.9, 1.3]]
  *
  * @this {AndroidDriver}
- * @param {import('./types').PerformanceDataOpts} opts
+ * @param {string} packageName The name of the package identifier to fetch the data for
+ * @param {import('./types').PerformanceDataType} dataType One of supported subsystem to fetch the data for.
  * @returns {Promise<any[][]>}
  */
-export async function mobileGetPerformanceData(opts) {
-  const {packageName, dataType} = requireArgs(['packageName', 'dataType'], opts);
+export async function mobileGetPerformanceData(packageName, dataType) {
   return await this.getPerformanceData(packageName, dataType);
 }
 

package/lib/commands/permissions.js

@@ -26,18 +26,35 @@ const PERMISSIONS_TYPE = Object.freeze({
 
 /**
  * @this {import('../driver').AndroidDriver}
- * @param {import('./types').ChangePermissionsOpts} opts
- * @returns {Promise<void>}
+ * @param {string | string[]} permissions If `target` is set to 'pm':
+ *  The full name of the permission to be changed
+ * or a list of permissions. Check https://developer.android.com/reference/android/Manifest.permission
+ * to get the full list of standard Android permssion names. Mandatory argument.
+ * If 'all' magic string is passed then the chosen action is going to be applied to all
+ * permisisons requested/granted by 'appPackage'.
+ * If `target` is set to 'appops':
+ * The full name of the appops permission to be changed
+ * or a list of permissions. Check AppOpsManager.java sources to get the full list of
+ * available appops permission names. Mandatory argument.
+ * Examples: 'ACTIVITY_RECOGNITION', 'SMS_FINANCIAL_TRANSACTIONS', 'READ_SMS', 'ACCESS_NOTIFICATIONS'.
+ * The 'all' magic string is unsupported.
+ * @param {string} [appPackage] The application package to set change permissions on. Defaults to the
+ * package name under test
+ * @param {string} [action] One of `PM_ACTION` values if `target` is set to 'pm', otherwise
+ * one of `APPOPS_ACTION` values
+ * @param {'pm' | 'appops'} [target='pm'] Either 'pm' or 'appops'. The 'appops' one requires
+ * 'adb_shell' server security option to be enabled.
  */
-export async function mobileChangePermissions(opts) {
-  const {
-    permissions,
-    appPackage = this.opts.appPackage,
-    action = _.toLower(opts.target) === PERMISSION_TARGET.APPOPS
-      ? APPOPS_ACTION.ALLOW
-      : PM_ACTION.GRANT,
-    target = PERMISSION_TARGET.PM,
-  } = opts;
+export async function mobileChangePermissions(
+  permissions,
+  appPackage,
+  action,
+  target = PERMISSION_TARGET.PM
+) {
+  appPackage ??= this.opts.appPackage;
+  action ??= _.toLower(target) === PERMISSION_TARGET.APPOPS
+    ? APPOPS_ACTION.ALLOW
+    : PM_ACTION.GRANT;
   if (_.isNil(permissions)) {
     throw new errors.InvalidArgumentError(`'permissions' argument is required`);
   }
@@ -64,11 +81,13 @@ export async function mobileChangePermissions(opts) {
 
 /**
  * @this {import('../driver').AndroidDriver}
- * @param {import('./types').GetPermissionsOpts} [opts={}]
+ * @param {string} [type='requested'] One of possible permission types to get.
+ * @param {string} [appPackage] The application package to set change permissions on.
+ * Defaults to the package name under test
  * @returns {Promise<string[]>}
  */
-export async function mobileGetPermissions(opts = {}) {
-  const {type = PERMISSIONS_TYPE.REQUESTED, appPackage = this.opts.appPackage} = opts;
+export async function mobileGetPermissions(type = PERMISSIONS_TYPE.REQUESTED, appPackage) {
+  appPackage ??= this.opts.appPackage;
   /**
    * @type {(pkg: string) => Promise<string[]>}
    */

package/lib/commands/{shell.js → shell.ts}

@@ -4,14 +4,13 @@ import _ from 'lodash';
 import {exec} from 'teen_process';
 import {ADB_SHELL_FEATURE} from '../utils';
 
-/**
- * @this {import('../driver').AndroidDriver}
- * @param {import('./types').ShellOpts} [opts={}]
- * @returns {Promise<string | {stderr: string; stdout: string}>};
- */
-export async function mobileShell(opts) {
+export async function mobileShell<T extends boolean>(
+  command: string,
+  args: string[] = [],
+  timeout: number = 20000,
+  includeStderr?: T,
+): Promise<T extends true ? { stdout: string; stderr: string; } : string> {
   this.assertFeatureEnabled(ADB_SHELL_FEATURE);
-  const {command, args = /** @type {string[]} */ ([]), timeout = 20000, includeStderr} = opts ?? {};
 
   if (!_.isString(command)) {
     throw new errors.InvalidArgumentError(`The 'command' argument is mandatory`);
@@ -22,11 +21,13 @@ export async function mobileShell(opts) {
   try {
     const {stdout, stderr} = await exec(this.adb.executable.path, adbArgs, {timeout});
     if (includeStderr) {
+      // @ts-ignore We know what we are doing here
       return {
         stdout,
         stderr,
       };
     }
+    // @ts-ignore We know what we are doing here
     return stdout;
   } catch (e) {
     const err = /** @type {import('teen_process').ExecError} */ (e);
@@ -37,7 +38,3 @@ export async function mobileShell(opts) {
     );
   }
 }
-
-/**
- * @typedef {import('appium-adb').ADB} ADB
- */