appium-adb 14.0.4 → 14.0.5

package/lib/tools/{app-commands.js → app-commands.ts}

@@ -3,9 +3,21 @@ import { fs, tempDir, util, system } from '@appium/support';
 import { log } from '../logger.js';
 import { waitForCondition } from 'asyncbox';
 import path from 'node:path';
-
-/** @type {import('./types').StringRecord<import('./types').InstallState>} */
-export const APP_INSTALL_STATE = {
+import type { ADB } from '../adb.js';
+import type { ExecError } from 'teen_process';
+import type {
+  StringRecord,
+  InstallState,
+  ResolveActivityOptions,
+  IsAppInstalledOptions,
+  StartUriOptions,
+  StartAppOptions,
+  AppInfo,
+  PackageActivityInfo,
+} from './types.js';
+
+// Constants
+export const APP_INSTALL_STATE: StringRecord<InstallState> = {
   UNKNOWN: 'unknown',
   NOT_INSTALLED: 'notInstalled',
   NEWER_VERSION_INSTALLED: 'newerVersionInstalled',
@@ -22,17 +34,17 @@ const RESOLVER_ACTIVITY_NAME = 'android/com.android.internal.app.ResolverActivit
 const MAIN_ACTION = 'android.intent.action.MAIN';
 const LAUNCHER_CATEGORY = 'android.intent.category.LAUNCHER';
 
+// Public methods
 
 /**
  * Verify whether the given argument is a
  * valid class name.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} classString - The actual class name to be verified.
- * @return {boolean} The result of Regexp.exec operation
+ * @param classString - The actual class name to be verified.
+ * @returns The result of Regexp.exec operation
  * or _null_ if no matches are found.
  */
-export function isValidClass (classString) {
+export function isValidClass (this: ADB, classString: string): boolean {
   // some.package/some.package.Activity
   return !!matchComponentName(classString);
 }
@@ -42,13 +54,12 @@ export function isValidClass (classString) {
  * given package. It is expected the package is already installed on
  * the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The target package identifier
- * @param {import('./types').ResolveActivityOptions} opts
- * @return {Promise<string>} Fully qualified name of the launchable activity
+ * @param pkg - The target package identifier
+ * @param opts - Options for resolving the activity
+ * @returns Fully qualified name of the launchable activity
  * @throws {Error} If there was an error while resolving the activity name
  */
-export async function resolveLaunchableActivity (pkg, opts = {}) {
+export async function resolveLaunchableActivity (this: ADB, pkg: string, opts: ResolveActivityOptions = {}): Promise<string> {
   const { preferCmd = true } = opts;
   if (!preferCmd || await this.getApiLevel() < 24) {
     const stdout = await this.shell(['dumpsys', 'package', pkg]);
@@ -65,9 +76,9 @@ export async function resolveLaunchableActivity (pkg, opts = {}) {
     try {
       const tmpApp = await this.pullApk(pkg, tmpRoot);
       const {apkActivity} = await this.packageAndLaunchActivityFromManifest(tmpApp);
-      return /** @type {string} */ (apkActivity);
+      return apkActivity as string;
     } catch (e) {
-      const err = /** @type {Error} */ (e);
+      const err = e as Error;
       log.debug(err.stack);
       log.warn(`Unable to resolve the launchable activity of '${pkg}'. ` +
         `The very first match of the dumpsys output is going to be used. ` +
@@ -92,33 +103,31 @@ export async function resolveLaunchableActivity (pkg, opts = {}) {
 
 /**
  * Forcefully stops the app and puts it in the "stopped" state.
- * Android treats a “stopped” app as if it was never launched since boot:
+ * Android treats a "stopped" app as if it was never launched since boot:
  * - It cannot receive broadcast intents (except for explicit ones).
  * - Scheduled jobs, alarms, and services are cancelled.
- * - The app won’t restart until the user explicitly launches it again.
- * It’s the same as when a user swipes an app away from Settings → Apps → Force Stop.
+ * - The app won't restart until the user explicitly launches it again.
+ * It's the same as when a user swipes an app away from Settings → Apps → Force Stop.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be stopped.
- * @return {Promise<string>} The output of the corresponding adb command.
+ * @param pkg - The package name to be stopped.
+ * @returns The output of the corresponding adb command.
  */
-export async function forceStop (pkg) {
+export async function forceStop (this: ADB, pkg: string): Promise<string> {
   return await this.shell(['am', 'force-stop', pkg]);
 }
 
 /**
- * Gracefully kills the app’s process, similar to how Android would do it
+ * Gracefully kills the app's process, similar to how Android would do it
  * automatically when low on memory.
- * It only kills the process, without changing the app’s “stopped” state.
+ * It only kills the process, without changing the app's "stopped" state.
  * Background services or broadcast receivers may restart soon after,
  * if they are still scheduled or registered.
  * No data or state (like alarms, jobs, etc.) are cleared.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be stopped.
- * @return {Promise<string>} The output of the corresponding adb command.
+ * @param pkg - The package name to be stopped.
+ * @returns The output of the corresponding adb command.
  */
-export async function killPackage (pkg) {
+export async function killPackage (this: ADB, pkg: string): Promise<string> {
   return await this.shell(['am', 'kill', pkg]);
 }
 
@@ -126,11 +135,10 @@ export async function killPackage (pkg) {
  * Clear the user data of the particular application on the device
  * under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be cleared.
- * @return {Promise<string>} The output of the corresponding adb command.
+ * @param pkg - The package name to be cleared.
+ * @returns The output of the corresponding adb command.
  */
-export async function clear (pkg) {
+export async function clear (this: ADB, pkg: string): Promise<string> {
   return await this.shell(['pm', 'clear', pkg]);
 }
 
@@ -139,15 +147,14 @@ export async function clear (pkg) {
  * This method is only useful on Android 6.0+ and for applications
  * that support components-based permissions setting.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {string} [apk] - The path to the actual apk file.
+ * @param pkg - The package name to be processed.
+ * @param apk - The path to the actual apk file.
  * @throws {Error} If there was an error while granting permissions
  */
-export async function grantAllPermissions (pkg, apk) {
+export async function grantAllPermissions (this: ADB, pkg: string, apk?: string): Promise<void> {
   const apiLevel = await this.getApiLevel();
   let targetSdk = 0;
-  let dumpsysOutput = null;
+  let dumpsysOutput: string | null = null;
   try {
     if (!apk) {
       /**
@@ -193,12 +200,11 @@ export async function grantAllPermissions (pkg, apk) {
  * This call is more performant than `grantPermission` one, since it combines
  * multiple `adb shell` calls into a single command.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {Array<string>} permissions - The list of permissions to be granted.
+ * @param pkg - The package name to be processed.
+ * @param permissions - The list of permissions to be granted.
  * @throws {Error} If there was an error while changing permissions.
  */
-export async function grantPermissions (pkg, permissions) {
+export async function grantPermissions (this: ADB, pkg: string, permissions: string[]): Promise<void> {
   // As it consumes more time for granting each permission,
   // trying to grant all permission by forming equivalent command.
   // Also, it is necessary to split long commands into chunks, since the maximum length of
@@ -207,7 +213,7 @@ export async function grantPermissions (pkg, permissions) {
   try {
     await this.shellChunks((perm) => ['pm', 'grant', pkg, perm], permissions);
   } catch (e) {
-    const err = /** @type {import('teen_process').ExecError} */(e);
+    const err = e as ExecError;
     if (!IGNORED_PERM_ERRORS.some((pattern) => pattern.test(err.stderr || err.message))) {
       throw err;
     }
@@ -217,16 +223,15 @@ export async function grantPermissions (pkg, permissions) {
 /**
  * Grant single permission for the particular package.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {string} permission - The full name of the permission to be granted.
+ * @param pkg - The package name to be processed.
+ * @param permission - The full name of the permission to be granted.
  * @throws {Error} If there was an error while changing permissions.
  */
-export async function grantPermission (pkg, permission) {
+export async function grantPermission (this: ADB, pkg: string, permission: string): Promise<void> {
   try {
     await this.shell(['pm', 'grant', pkg, permission]);
   } catch (e) {
-    const err = /** @type {import('teen_process').ExecError} */(e);
+    const err = e as ExecError;
     if (!NOT_CHANGEABLE_PERM_ERROR.test(err.stderr || err.message)) {
       throw err;
     }
@@ -236,16 +241,15 @@ export async function grantPermission (pkg, permission) {
 /**
  * Revoke single permission from the particular package.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {string} permission - The full name of the permission to be revoked.
+ * @param pkg - The package name to be processed.
+ * @param permission - The full name of the permission to be revoked.
  * @throws {Error} If there was an error while changing permissions.
  */
-export async function revokePermission (pkg, permission) {
+export async function revokePermission (this: ADB, pkg: string, permission: string): Promise<void> {
   try {
     await this.shell(['pm', 'revoke', pkg, permission]);
   } catch (e) {
-    const err = /** @type {import('teen_process').ExecError} */(e);
+    const err = e as ExecError;
     if (!NOT_CHANGEABLE_PERM_ERROR.test(err.stderr || err.message)) {
       throw err;
     }
@@ -255,14 +259,13 @@ export async function revokePermission (pkg, permission) {
 /**
  * Retrieve the list of granted permissions for the particular package.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {string?} [cmdOutput=null] - Optional parameter containing command output of
+ * @param pkg - The package name to be processed.
+ * @param cmdOutput - Optional parameter containing command output of
  * _dumpsys package_ command. It may speed up the method execution.
- * @return {Promise<string[]>} The list of granted permissions or an empty list.
+ * @returns The list of granted permissions or an empty list.
  * @throws {Error} If there was an error while changing permissions.
  */
-export async function getGrantedPermissions (pkg, cmdOutput = null) {
+export async function getGrantedPermissions (this: ADB, pkg: string, cmdOutput: string | null = null): Promise<string[]> {
   log.debug('Retrieving granted permissions');
   const stdout = cmdOutput || await this.shell(['dumpsys', 'package', pkg]);
   return extractMatchingPermissions(stdout, ['install', 'runtime'], true);
@@ -271,13 +274,12 @@ export async function getGrantedPermissions (pkg, cmdOutput = null) {
 /**
  * Retrieve the list of denied permissions for the particular package.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {string?} [cmdOutput=null] - Optional parameter containing command output of
+ * @param pkg - The package name to be processed.
+ * @param cmdOutput - Optional parameter containing command output of
  * _dumpsys package_ command. It may speed up the method execution.
- * @return {Promise<string[]>} The list of denied permissions or an empty list.
+ * @returns The list of denied permissions or an empty list.
  */
-export async function getDeniedPermissions (pkg, cmdOutput = null) {
+export async function getDeniedPermissions (this: ADB, pkg: string, cmdOutput: string | null = null): Promise<string[]> {
   log.debug('Retrieving denied permissions');
   const stdout = cmdOutput || await this.shell(['dumpsys', 'package', pkg]);
   return extractMatchingPermissions(stdout, ['install', 'runtime'], false);
@@ -286,13 +288,12 @@ export async function getDeniedPermissions (pkg, cmdOutput = null) {
 /**
  * Retrieve the list of requested permissions for the particular package.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
- * @param {string?} [cmdOutput=null] - Optional parameter containing command output of
+ * @param pkg - The package name to be processed.
+ * @param cmdOutput - Optional parameter containing command output of
  *                                    _dumpsys package_ command. It may speed up the method execution.
- * @return {Promise<string[]>} The list of requested permissions or an empty list.
+ * @returns The list of requested permissions or an empty list.
  */
-export async function getReqPermissions (pkg, cmdOutput = null) {
+export async function getReqPermissions (this: ADB, pkg: string, cmdOutput: string | null = null): Promise<string[]> {
   log.debug('Retrieving requested permissions');
   const stdout = cmdOutput || await this.shell(['dumpsys', 'package', pkg]);
   return extractMatchingPermissions(stdout, ['requested']);
@@ -301,15 +302,14 @@ export async function getReqPermissions (pkg, cmdOutput = null) {
 /**
  * Stop the particular package if it is running and clears its application data.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The package name to be processed.
+ * @param pkg - The package name to be processed.
  */
-export async function stopAndClear (pkg) {
+export async function stopAndClear (this: ADB, pkg: string): Promise<void> {
   try {
     await this.forceStop(pkg);
     await this.clear(pkg);
   } catch (e) {
-    const err = /** @type {Error} */ (e);
+    const err = e as Error;
     throw new Error(`Cannot stop and clear ${pkg}. Original error: ${err.message}`);
   }
 }
@@ -317,19 +317,19 @@ export async function stopAndClear (pkg) {
 /**
  * Get the package info from the installed application.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The name of the installed package.
- * @return {Promise<import('./types').AppInfo>} The parsed application information.
+ * @param pkg - The name of the installed package.
+ * @returns The parsed application information.
  */
-export async function getPackageInfo (pkg) {
+export async function getPackageInfo (this: ADB, pkg: string): Promise<AppInfo> {
   log.debug(`Getting package info for '${pkg}'`);
-  const result = {name: pkg};
-  let stdout;
+  const result: AppInfo = {name: pkg};
+  let stdout: string;
   try {
     stdout = await this.shell(['dumpsys', 'package', pkg]);
   } catch (err) {
-    log.debug(err.stack);
-    log.warn(`Got an unexpected error while dumping package info: ${err.message}`);
+    const error = err as Error;
+    log.debug(error.stack);
+    log.warn(`Got an unexpected error while dumping package info: ${error.message}`);
     return result;
   }
 
@@ -353,13 +353,12 @@ export async function getPackageInfo (pkg) {
 /**
  * Fetches base.apk of the given package to the local file system
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg The package identifier (must be already installed on the device)
- * @param {string} tmpDir The destination folder path
- * @returns {Promise<string>} Full path to the downloaded file
+ * @param pkg - The package identifier (must be already installed on the device)
+ * @param tmpDir - The destination folder path
+ * @returns Full path to the downloaded file
  * @throws {Error} If there was an error while fetching the .apk
  */
-export async function pullApk (pkg, tmpDir) {
+export async function pullApk (this: ADB, pkg: string, tmpDir: string): Promise<string> {
   const stdout = _.trim(await this.shell(['pm', 'path', pkg]));
   const packageMarker = 'package:';
   if (!_.startsWith(stdout, packageMarker)) {
@@ -378,11 +377,10 @@ export async function pullApk (pkg, tmpDir) {
  * The action literally simulates
  * clicking the corresponding application icon on the dashboard.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} appId - Application package identifier
+ * @param appId - Application package identifier
  * @throws {Error} If the app cannot be activated
  */
-export async function activateApp (appId) {
+export async function activateApp (this: ADB, appId: string): Promise<void> {
   log.debug(`Activating '${appId}'`);
   const apiLevel = await this.getApiLevel();
   // Fallback to Monkey in older APIs
@@ -398,7 +396,8 @@ export async function activateApp (appId) {
       output = await this.shell(cmd);
       log.debug(`Command stdout: ${output}`);
     } catch (e) {
-      throw log.errorWithException(`Cannot activate '${appId}'. Original error: ${e.message}`);
+      const error = e as Error;
+      throw log.errorWithException(`Cannot activate '${appId}'. Original error: ${error.message}`);
     }
     if (output.includes('monkey aborted')) {
       throw log.errorWithException(`Cannot activate '${appId}'. Are you sure it is installed?`);
@@ -435,19 +434,17 @@ export async function activateApp (appId) {
 /**
  * Check whether the particular package is present on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The name of the package to check.
- * @param {import('./types').IsAppInstalledOptions} [opts={}]
- * @return {Promise<boolean>} True if the package is installed.
+ * @param pkg - The name of the package to check.
+ * @param opts - Options for checking installation
+ * @returns True if the package is installed.
  */
-export async function isAppInstalled (pkg, opts = {}) {
+export async function isAppInstalled (this: ADB, pkg: string, opts: IsAppInstalledOptions = {}): Promise<boolean> {
   const {
     user,
   } = opts;
 
   log.debug(`Getting install status for ${pkg}`);
-  /** @type {boolean} */
-  let isInstalled;
+  let isInstalled: boolean;
   if (await this.getApiLevel() < 26) {
     try {
       const cmd = ['pm', 'path'];
@@ -465,13 +462,13 @@ export async function isAppInstalled (pkg, opts = {}) {
     if (util.hasValue(user)) {
       cmd.push('--user', user);
     }
-    /** @type {string} */
-    let stdout;
+    let stdout: string;
     try {
       stdout = await this.shell(cmd);
     } catch (e) {
+      const error = e as ExecError;
       // https://github.com/appium/appium-uiautomator2-driver/issues/810
-      if (_.includes(e.stderr || e.stdout || e.message, 'access user') && _.isEmpty(user)) {
+      if (_.includes(error.stderr || error.stdout || error.message, 'access user') && _.isEmpty(user)) {
         stdout = await this.shell([...cmd, '--user', '0']);
       } else {
         throw e;
@@ -486,12 +483,11 @@ export async function isAppInstalled (pkg, opts = {}) {
 /**
  * Start the particular URI on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} uri - The name of URI to start.
- * @param {string?} [pkg=null] - The name of the package to start the URI with.
- * @param {import('./types').StartUriOptions} [opts={}]
+ * @param uri - The name of URI to start.
+ * @param pkg - The name of the package to start the URI with.
+ * @param opts - Options for starting the URI
  */
-export async function startUri (uri, pkg = null, opts = {}) {
+export async function startUri (this: ADB, uri: string, pkg: string | null = null, opts: StartUriOptions = {}): Promise<void> {
   const {
     waitForLaunch = true,
   } = opts;
@@ -523,53 +519,51 @@ export async function startUri (uri, pkg = null, opts = {}) {
 /**
  * Start the particular package/activity on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {import('./types').StartAppOptions} startAppOptions - Startup options mapping.
- * @return {Promise<string>} The output of the corresponding adb command.
+ * @param startAppOptions - Startup options mapping.
+ * @returns The output of the corresponding adb command.
  * @throws {Error} If there is an error while executing the activity
  */
-export async function startApp (startAppOptions) {
+export async function startApp (this: ADB, startAppOptions: StartAppOptions): Promise<string> {
   if (!startAppOptions.pkg || !(startAppOptions.activity || startAppOptions.action)) {
     throw new Error('pkg, and activity or intent action, are required to start an application');
   }
 
-  startAppOptions = _.clone(startAppOptions);
-  if (startAppOptions.activity) {
-    startAppOptions.activity = startAppOptions.activity.replace('$', '\\$');
+  const options = _.clone(startAppOptions);
+  if (options.activity) {
+    options.activity = options.activity.replace('$', '\\$');
   }
   // initializing defaults
-  _.defaults(startAppOptions, {
-    waitPkg: startAppOptions.pkg,
+  _.defaults(options, {
+    waitPkg: options.pkg,
     waitForLaunch: true,
     waitActivity: false,
     retry: true,
     stopApp: true
   });
   // preventing null waitpkg
-  startAppOptions.waitPkg = startAppOptions.waitPkg || startAppOptions.pkg;
+  options.waitPkg = options.waitPkg || options.pkg;
 
   const apiLevel = await this.getApiLevel();
-  const cmd = buildStartCmd(startAppOptions, apiLevel);
-  const intentName = `${startAppOptions.action}${startAppOptions.optionalIntentArguments
-    ? ' ' + startAppOptions.optionalIntentArguments
+  const cmd = buildStartCmd(options, apiLevel);
+  const intentName = `${options.action}${options.optionalIntentArguments
+    ? ' ' + options.optionalIntentArguments
     : ''}`;
   try {
-    const shellOpts = {};
-    if (_.isInteger(startAppOptions.waitDuration)
-      // @ts-ignore waitDuration is an integer here
-      && startAppOptions.waitDuration >= 0) {
-      shellOpts.timeout = startAppOptions.waitDuration;
+    const shellOpts: { timeout?: number } = {};
+    if (options.waitDuration !== undefined && _.isInteger(options.waitDuration)
+      && options.waitDuration >= 0) {
+      shellOpts.timeout = options.waitDuration;
     }
     const stdout = await this.shell(cmd, shellOpts);
     if (stdout.includes('Error: Activity class') && stdout.includes('does not exist')) {
-      if (startAppOptions.retry && startAppOptions.activity && !startAppOptions.activity.startsWith('.')) {
+      if (options.retry && options.activity && !options.activity.startsWith('.')) {
         log.debug(`We tried to start an activity that doesn't exist, ` +
-                  `retrying with '.${startAppOptions.activity}' activity name`);
-        startAppOptions.activity = `.${startAppOptions.activity}`;
-        startAppOptions.retry = false;
-        return await this.startApp(startAppOptions);
+                  `retrying with '.${options.activity}' activity name`);
+        options.activity = `.${options.activity}`;
+        options.retry = false;
+        return await this.startApp(options);
       }
-      throw new Error(`Activity name '${startAppOptions.activity}' used to start the app doesn't ` +
+      throw new Error(`Activity name '${options.activity}' used to start the app doesn't ` +
                       `exist or cannot be launched! Make sure it exists and is a launchable activity`);
     } else if (stdout.includes('Error: Intent does not match any activities')
     || stdout.includes('Error: Activity not started, unable to resolve Intent')) {
@@ -577,27 +571,28 @@ export async function startApp (startAppOptions) {
                       `exist or cannot be launched! Make sure it exists and is a launchable activity`);
     } else if (stdout.includes('java.lang.SecurityException')) {
       // if the app is disabled on a real device it will throw a security exception
-      throw new Error(`The permission to start '${startAppOptions.activity}' activity has been denied.` +
+      throw new Error(`The permission to start '${options.activity}' activity has been denied.` +
                       `Make sure the activity/package names are correct.`);
     }
-    if (startAppOptions.waitActivity) {
-      await this.waitForActivity(startAppOptions.waitPkg, startAppOptions.waitActivity, startAppOptions.waitDuration);
+    if (options.waitActivity) {
+      await this.waitForActivity(options.waitPkg, options.waitActivity, options.waitDuration);
     }
     return stdout;
   } catch (e) {
-    const appDescriptor = startAppOptions.pkg || intentName;
+    const error = e as Error;
+    const appDescriptor = options.pkg || intentName;
     throw new Error(`Cannot start the '${appDescriptor}' application. ` +
       `Consider checking the driver's troubleshooting documentation. ` +
-      `Original error: ${e.message}`);
+      `Original error: ${error.message}`);
   }
 }
 
 /**
  * Helper method to call `adb dumpsys window windows/displays`
- * @this {import('../adb.js').ADB}
- * @returns {Promise<string>}
+ *
+ * @returns The output of the dumpsys command
  */
-export async function dumpWindows () {
+export async function dumpWindows (this: ADB): Promise<string> {
   const apiLevel = await this.getApiLevel();
 
   // With version 29, Android changed the dumpsys syntax
@@ -610,18 +605,18 @@ export async function dumpWindows () {
 /**
  * Get the name of currently focused package and activity.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<import('./types').PackageActivityInfo>}
+ * @returns The focused package and activity information
  * @throws {Error} If there is an error while parsing the data.
  */
-export async function getFocusedPackageAndActivity () {
+export async function getFocusedPackageAndActivity (this: ADB): Promise<PackageActivityInfo> {
   log.debug('Getting focused package and activity');
-  let stdout;
+  let stdout: string;
   try {
     stdout = await this.dumpWindows();
   } catch (e) {
+    const error = e as Error;
     throw new Error(
-      `Could not retrieve the currently focused package and activity. Original error: ${e.message}`
+      `Could not retrieve the currently focused package and activity. Original error: ${error.message}`
     );
   }
 
@@ -634,17 +629,14 @@ export async function getFocusedPackageAndActivity () {
   const nullCurrentFocusRe = /^\s*mCurrentFocus=null/m;
   const currentFocusAppRe = new RegExp('^\\s*mCurrentFocus.+\\{.+\\s([^\\s\\/]+)\\/([^\\s]+)\\b', 'mg');
 
-  /** @type {import('./types').PackageActivityInfo[]} */
-  const focusedAppCandidates = [];
-  /** @type {import('./types').PackageActivityInfo[]} */
-  const currentFocusAppCandidates = [];
-  /** @type {[import('./types').PackageActivityInfo[], RegExp][]} */
-  const pairs = [
+  const focusedAppCandidates: PackageActivityInfo[] = [];
+  const currentFocusAppCandidates: PackageActivityInfo[] = [];
+  const pairs: [PackageActivityInfo[], RegExp][] = [
     [focusedAppCandidates, focusedAppRe],
     [currentFocusAppCandidates, currentFocusAppRe]
   ];
   for (const [candidates, pattern] of pairs) {
-    let match;
+    let match: RegExpExecArray | null;
     while ((match = pattern.exec(stdout))) {
       candidates.push({
         appPackage: match[1].trim(),
@@ -685,28 +677,26 @@ export async function getFocusedPackageAndActivity () {
 /**
  * Wait for the given activity to be focused/non-focused.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The name of the package to wait for.
- * @param {string} activity - The name of the activity, belonging to that package,
+ * @param pkg - The name of the package to wait for.
+ * @param activity - The name of the activity, belonging to that package,
  *                            to wait for.
- * @param {boolean} waitForStop - Whether to wait until the activity is focused (true)
+ * @param waitForStop - Whether to wait until the activity is focused (true)
  *                                or is not focused (false).
- * @param {number} [waitMs=20000] - Number of milliseconds to wait before timeout occurs.
- * @throws {error} If timeout happens.
+ * @param waitMs - Number of milliseconds to wait before timeout occurs.
+ * @throws {Error} If timeout happens.
  */
-export async function waitForActivityOrNot (pkg, activity, waitForStop, waitMs = 20000) {
+export async function waitForActivityOrNot (this: ADB, pkg: string, activity: string, waitForStop: boolean, waitMs: number = 20000): Promise<void> {
   if (!pkg || !activity) {
     throw new Error('Package and activity required.');
   }
 
-  const splitNames = (/** @type {string} */ names) => names.split(',').map(_.trim);
+  const splitNames = (names: string) => names.split(',').map(_.trim);
   const allPackages = splitNames(pkg);
   const allActivities = splitNames(activity);
 
-  const toFullyQualifiedActivityName = (/** @type {string} */ prefix, /** @type {string} */ suffix) =>
+  const toFullyQualifiedActivityName = (prefix: string, suffix: string) =>
     `${prefix}${suffix}`.replace(/\/\.?/g, '.').replace(/\.{2,}/g, '.');
-  /** @type {Set<string>} */
-  const possibleActivityNamesSet = new Set();
+  const possibleActivityNamesSet = new Set<string>();
   for (const oneActivity of allActivities) {
     if (oneActivity.startsWith('.')) {
       // add the package name if activity is not full qualified
@@ -741,12 +731,13 @@ export async function waitForActivityOrNot (pkg, activity, waitForStop, waitMs =
   );
 
   const conditionFunc = async () => {
-    let appPackage;
-    let appActivity;
+    let appPackage: string | null | undefined;
+    let appActivity: string | null | undefined;
     try {
       ({appPackage, appActivity} = await this.getFocusedPackageAndActivity());
     } catch (e) {
-      log.debug(e.message);
+      const error = e as Error;
+      log.debug(error.message);
       return false;
     }
     if (appActivity && appPackage) {
@@ -785,42 +776,38 @@ export async function waitForActivityOrNot (pkg, activity, waitForStop, waitMs =
 /**
  * Wait for the given activity to be focused
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The name of the package to wait for.
- * @param {string} act - The name of the activity, belonging to that package,
+ * @param pkg - The name of the package to wait for.
+ * @param act - The name of the activity, belonging to that package,
  *                            to wait for.
- * @param {number} [waitMs=20000] - Number of milliseconds to wait before timeout occurs.
- * @throws {error} If timeout happens.
+ * @param waitMs - Number of milliseconds to wait before timeout occurs.
+ * @throws {Error} If timeout happens.
  */
-export async function waitForActivity (pkg, act, waitMs = 20000) {
+export async function waitForActivity (this: ADB, pkg: string, act: string, waitMs: number = 20000): Promise<void> {
   await this.waitForActivityOrNot(pkg, act, false, waitMs);
 }
 
 /**
  * Wait for the given activity to be non-focused.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The name of the package to wait for.
- * @param {string} act - The name of the activity, belonging to that package,
+ * @param pkg - The name of the package to wait for.
+ * @param act - The name of the activity, belonging to that package,
  *                            to wait for.
- * @param {number} [waitMs=20000] - Number of milliseconds to wait before timeout occurs.
- * @throws {error} If timeout happens.
+ * @param waitMs - Number of milliseconds to wait before timeout occurs.
+ * @throws {Error} If timeout happens.
  */
-export async function waitForNotActivity (pkg, act, waitMs = 20000) {
+export async function waitForNotActivity (this: ADB, pkg: string, act: string, waitMs: number = 20000): Promise<void> {
   await this.waitForActivityOrNot(pkg, act, true, waitMs);
 }
 
-// #region Private functions
-
 /**
  * Builds command line representation for the given
  * application startup options
  *
- * @param {StartCmdOptions} startAppOptions - Application options mapping
- * @param {number} apiLevel - The actual OS API level
- * @returns {string[]} The actual command line array
+ * @param startAppOptions - Application options mapping
+ * @param apiLevel - The actual OS API level
+ * @returns The actual command line array
  */
-export function buildStartCmd (startAppOptions, apiLevel) {
+export function buildStartCmd (startAppOptions: StartCmdOptions, apiLevel: number): string[] {
   const {
     user,
     waitForLaunch,
@@ -860,70 +847,12 @@ export function buildStartCmd (startAppOptions, apiLevel) {
   return cmd;
 }
 
-/**
- *
- * @param {string} value expect optionalIntentArguments to be a single string of the form:
- *     "-flag key"
- *     "-flag key value"
- * or a combination of these (e.g., "-flag1 key1 -flag2 key2 value2")
- * @returns {string[]}
- */
-function parseOptionalIntentArguments(value) {
-  // take a string and parse out the part before any spaces, and anything after
-  // the first space
-  /** @type {(str: string) => string[]} */
-  const parseKeyValue = (str) => {
-    str = str.trim();
-    const spacePos = str.indexOf(' ');
-    if (spacePos < 0) {
-      return str.length ? [str] : [];
-    } else {
-      return [str.substring(0, spacePos).trim(), str.substring(spacePos + 1).trim()];
-    }
-  };
-
-  // cycle through the optionalIntentArguments and pull out the arguments
-  // add a space initially so flags can be distinguished from arguments that
-  // have internal hyphens
-  let optionalIntentArguments = ` ${value}`;
-  const re = / (-[^\s]+) (.+)/;
-  /** @type {string[]} */
-  const result = [];
-  while (true) {
-    const args = re.exec(optionalIntentArguments);
-    if (!args) {
-      if (optionalIntentArguments.length) {
-        // no more flags, so the remainder can be treated as 'key' or 'key value'
-        result.push(...parseKeyValue(optionalIntentArguments));
-      }
-      // we are done
-      return result;
-    }
-
-    // take the flag and see if it is at the beginning of the string
-    // if it is not, then it means we have been through already, and
-    // what is before the flag is the argument for the previous flag
-    const flag = args[1];
-    const flagPos = optionalIntentArguments.indexOf(flag);
-    if (flagPos !== 0) {
-      const prevArgs = optionalIntentArguments.substring(0, flagPos);
-      result.push(...parseKeyValue(prevArgs));
-    }
-
-    // add the flag, as there are no more earlier arguments
-    result.push(flag);
-
-    // make optionalIntentArguments hold the remainder
-    optionalIntentArguments = args[2];
-  }
-}
-
 /**
  * Parses the name of launchable package activity
  * from dumpsys output.
  *
- * @param {string} dumpsys the actual dumpsys output
- * @returns {string[]} Either the fully qualified
+ * @param dumpsys - The actual dumpsys output
+ * @returns Either the fully qualified
  * activity name as a single list item or an empty list if nothing could be parsed.
  * In Android 6 and older there is no reliable way to determine
  * the category name for the given activity, so this API just
@@ -931,12 +860,12 @@ function parseOptionalIntentArguments(value) {
  * with the expectation that the app manifest could be parsed next
  * in order to determine category names for these.
  */
-export function parseLaunchableActivityNames (dumpsys) {
+export function parseLaunchableActivityNames (dumpsys: string): string[] {
   const mainActivityNameRe = new RegExp(`^\\s*${_.escapeRegExp(MAIN_ACTION)}:$`);
   const categoryNameRe = /^\s*Category:\s+"([a-zA-Z0-9._/-]+)"$/;
-  const blocks = [];
-  let blockStartIndent;
-  let block = [];
+  const blocks: string[][] = [];
+  let blockStartIndent: number | null | undefined;
+  let block: string[] = [];
   for (const line of dumpsys.split('\n').map(_.trimEnd)) {
     const currentIndent = line.length - _.trimStart(line).length;
     if (mainActivityNameRe.test(line)) {
@@ -965,7 +894,7 @@ export function parseLaunchableActivityNames (dumpsys) {
     blocks.push(block);
   }
 
-  const result = [];
+  const result: string[] = [];
   for (const item of blocks) {
     let hasCategory = false;
     let isLauncherCategory = false;
@@ -1004,48 +933,30 @@ export function parseLaunchableActivityNames (dumpsys) {
 /**
  * Check if the given string is a valid component name
  *
- * @param {string} classString The string to verify
- * @return {RegExpExecArray?} The result of Regexp.exec operation
+ * @param classString - The string to verify
+ * @returns The result of Regexp.exec operation
  * or _null_ if no matches are found
  */
-export function matchComponentName (classString) {
+export function matchComponentName (classString: string): RegExpExecArray | null {
   // some.package/some.package.Activity
   return /^[\p{L}0-9./_]+$/u.exec(classString);
 }
 
-/**
- * Escapes special characters in command line arguments.
- * This is needed to avoid possible issues with how system `spawn`
- * call handles them.
- * See https://discuss.appium.io/t/how-to-modify-wd-proxy-and-uiautomator2-source-code-to-support-unicode/33466
- * for more details.
- *
- * @param {string} arg Non-escaped argument string
- * @returns The escaped argument
- */
-function escapeShellArg (arg) {
-  arg = `${arg}`;
-  if (system.isWindows()) {
-    return /[&|^\s]/.test(arg) ? `"${arg.replace(/"/g, '""')}"` : arg;
-  }
-  return arg.replace(/&/g, '\\&');
-}
-
 /**
  * Retrieves the list of permission names encoded in `dumpsys package` command output.
  *
- * @param {string} dumpsysOutput - The actual command output.
- * @param {string[]} groupNames - The list of group names to list permissions for.
- * @param {boolean?} [grantedState=null] - The expected state of `granted` attribute to filter with.
+ * @param dumpsysOutput - The actual command output.
+ * @param groupNames - The list of group names to list permissions for.
+ * @param grantedState - The expected state of `granted` attribute to filter with.
  *  No filtering is done if the parameter is not set.
- * @returns {string[]} The list of matched permission names or an empty list if no matches were found.
+ * @returns The list of matched permission names or an empty list if no matches were found.
  */
-export function extractMatchingPermissions (dumpsysOutput, groupNames, grantedState = null) {
-  const groupPatternByName = (groupName) => new RegExp(`^(\\s*${_.escapeRegExp(groupName)} permissions:[\\s\\S]+)`, 'm');
+export function extractMatchingPermissions (dumpsysOutput: string, groupNames: string[], grantedState: boolean | null = null): string[] {
+  const groupPatternByName = (groupName: string) => new RegExp(`^(\\s*${_.escapeRegExp(groupName)} permissions:[\\s\\S]+)`, 'm');
   const indentPattern = /\S|$/;
   const permissionNamePattern = /android\.\w*\.?permission\.\w+/;
   const grantedStatePattern = /\bgranted=(\w+)/;
-  const result = [];
+  const result: Array<{ permission: string; granted?: boolean }> = [];
   for (const groupName of groupNames) {
     const groupMatch = groupPatternByName(groupName).exec(dumpsysOutput);
     if (!groupMatch) {
@@ -1068,7 +979,7 @@ export function extractMatchingPermissions (dumpsysOutput, groupNames, grantedSt
       if (!permissionNameMatch) {
         continue;
       }
-      const item = {
+      const item: { permission: string; granted?: boolean } = {
         permission: permissionNameMatch[0],
       };
       const grantedStateMatch = grantedStatePattern.exec(line);
@@ -1090,11 +1001,10 @@ export function extractMatchingPermissions (dumpsysOutput, groupNames, grantedSt
 /**
  * Broadcast a message to the given intent.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} intent - The name of the intent to broadcast to.
- * @throws {error} If intent name is not a valid class name.
+ * @param intent - The name of the intent to broadcast to.
+ * @throws {Error} If intent name is not a valid class name.
  */
-export async function broadcast (intent) {
+export async function broadcast (this: ADB, intent: string): Promise<void> {
   if (!this.isValidClass(intent)) {
     throw new Error(`Invalid intent ${intent}`);
   }
@@ -1105,11 +1015,10 @@ export async function broadcast (intent) {
 /**
  * Get the list of process ids for the particular package on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg
- * @returns {Promise<number[]>} The list of matched process IDs or an empty list.
+ * @param pkg - The package name
+ * @returns The list of matched process IDs or an empty list.
  */
-export async function listAppProcessIds (pkg) {
+export async function listAppProcessIds (this: ADB, pkg: string): Promise<number[]> {
   log.debug(`Getting IDs of all '${pkg}' package`);
   const pidRegex = new RegExp(`ProcessRecord\\{[\\w]+\\s+(\\d+):${_.escapeRegExp(pkg)}\\/`);
   const processesInfo = await this.shell(['dumpsys', 'activity', 'processes']);
@@ -1124,25 +1033,101 @@ export async function listAppProcessIds (pkg) {
  * Check whether the process with the particular name is running on the device
  * under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} pkg - The id of the package to be checked.
+ * @param pkg - The id of the package to be checked.
  * @returns True if the given package is running.
  */
-export async function isAppRunning (pkg) {
+export async function isAppRunning (this: ADB, pkg: string): Promise<boolean> {
   return !_.isEmpty(await this.listAppProcessIds(pkg));
 }
 
+// Private methods
+
+/**
+ * Parses optional intent arguments from a string.
+ *
+ * @param value - Expect optionalIntentArguments to be a single string of the form:
+ *     "-flag key"
+ *     "-flag key value"
+ * or a combination of these (e.g., "-flag1 key1 -flag2 key2 value2")
+ * @returns Parsed arguments array
+ */
+function parseOptionalIntentArguments(value: string): string[] {
+  // take a string and parse out the part before any spaces, and anything after
+  // the first space
+  const parseKeyValue = (str: string): string[] => {
+    str = str.trim();
+    const spacePos = str.indexOf(' ');
+    if (spacePos < 0) {
+      return str.length ? [str] : [];
+    } else {
+      return [str.substring(0, spacePos).trim(), str.substring(spacePos + 1).trim()];
+    }
+  };
+
+  // cycle through the optionalIntentArguments and pull out the arguments
+  // add a space initially so flags can be distinguished from arguments that
+  // have internal hyphens
+  let optionalIntentArguments = ` ${value}`;
+  const re = / (-[^\s]+) (.+)/;
+  const result: string[] = [];
+  while (true) {
+    const args = re.exec(optionalIntentArguments);
+    if (!args) {
+      if (optionalIntentArguments.length) {
+        // no more flags, so the remainder can be treated as 'key' or 'key value'
+        result.push(...parseKeyValue(optionalIntentArguments));
+      }
+      // we are done
+      return result;
+    }
+
+    // take the flag and see if it is at the beginning of the string
+    // if it is not, then it means we have been through already, and
+    // what is before the flag is the argument for the previous flag
+    const flag = args[1];
+    const flagPos = optionalIntentArguments.indexOf(flag);
+    if (flagPos !== 0) {
+      const prevArgs = optionalIntentArguments.substring(0, flagPos);
+      result.push(...parseKeyValue(prevArgs));
+    }
+
+    // add the flag, as there are no more earlier arguments
+    result.push(flag);
+
+    // make optionalIntentArguments hold the remainder
+    optionalIntentArguments = args[2];
+  }
+}
+
 /**
- * @typedef {Object} StartCmdOptions
- * @property {number|string} [user]
- * @property {boolean} [waitForLaunch]
- * @property {string} [pkg]
- * @property {string} [activity]
- * @property {string} [action]
- * @property {string} [category]
- * @property {boolean} [stopApp]
- * @property {string} [flags]
- * @property {string} [optionalIntentArguments]
+ * Escapes special characters in command line arguments.
+ * This is needed to avoid possible issues with how system `spawn`
+ * call handles them.
+ * See https://discuss.appium.io/t/how-to-modify-wd-proxy-and-uiautomator2-source-code-to-support-unicode/33466
+ * for more details.
+ *
+ * @param arg - Non-escaped argument string
+ * @returns The escaped argument
  */
+function escapeShellArg (arg: string): string {
+  arg = `${arg}`;
+  if (system.isWindows()) {
+    return /[&|^\s]/.test(arg) ? `"${arg.replace(/"/g, '""')}"` : arg;
+  }
+  return arg.replace(/&/g, '\\&');
+}
+
+// Type definitions
+
+export interface StartCmdOptions {
+  user?: number | string;
+  waitForLaunch?: boolean;
+  pkg?: string;
+  activity?: string;
+  action?: string;
+  category?: string;
+  stopApp?: boolean;
+  flags?: string;
+  optionalIntentArguments?: string;
+}
 
-// #endregion