appium-adb 14.0.4 → 14.0.6

package/lib/tools/{device-settings.js → device-settings.ts}

@@ -3,30 +3,32 @@ import _ from 'lodash';
 import { retryInterval } from 'asyncbox';
 import { util } from '@appium/support';
 import B from 'bluebird';
+import type { ADB } from '../adb.js';
+import type { SetPropOpts } from './types.js';
+import type { ExecError } from 'teen_process';
 
 const ANIMATION_SCALE_KEYS = [
   'animator_duration_scale',
   'transition_animation_scale',
   'window_animation_scale'
-];
+] as const;
 const HIDDEN_API_POLICY_KEYS = [
   'hidden_api_policy_pre_p_apps',
   'hidden_api_policy_p_apps',
   'hidden_api_policy'
-];
+] as const;
 
 /**
  * Get the particular property of the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} property - The name of the property. This name should
+ * @param property - The name of the property. This name should
  *                            be known to _adb shell getprop_ tool.
  *
- * @return {Promise<string>} The value of the given property.
+ * @returns The value of the given property.
  */
-export async function getDeviceProperty (property) {
-  let stdout = await this.shell(['getprop', property]);
-  let val = stdout.trim();
+export async function getDeviceProperty (this: ADB, property: string): Promise<string> {
+  const stdout = await this.shell(['getprop', property]);
+  const val = stdout.trim();
   log.debug(`Current device property '${property}': ${val}`);
   return val;
 }
@@ -34,15 +36,14 @@ export async function getDeviceProperty (property) {
 /**
  * Set the particular property of the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {string} prop - The name of the property. This name should
+ * @param prop - The name of the property. This name should
  *                            be known to _adb shell setprop_ tool.
- * @param {string} val - The new property value.
- * @param {import('./types').SetPropOpts} [opts={}]
+ * @param val - The new property value.
+ * @param opts
  *
- * @throws {error} If _setprop_ utility fails to change property value.
+ * @throws If _setprop_ utility fails to change property value.
  */
-export async function setDeviceProperty (prop, val, opts = {}) {
+export async function setDeviceProperty (this: ADB, prop: string, val: string, opts: SetPropOpts = {}): Promise<void> {
   const {privileged = true} = opts;
   log.debug(`Setting device property '${prop}' to '${val}'`);
   await this.shell(['setprop', prop, val], {
@@ -51,79 +52,70 @@ export async function setDeviceProperty (prop, val, opts = {}) {
 }
 
 /**
- * @this {import('../adb.js').ADB}
- * @return {Promise<string>} Current system language on the device under test.
+ * @returns Current system language on the device under test.
  */
-export async function getDeviceSysLanguage () {
+export async function getDeviceSysLanguage (this: ADB): Promise<string> {
   return await this.getDeviceProperty('persist.sys.language');
 }
 
 /**
- * @this {import('../adb.js').ADB}
- * @return {Promise<string>} Current country name on the device under test.
+ * @returns Current country name on the device under test.
  */
-export async function getDeviceSysCountry () {
+export async function getDeviceSysCountry (this: ADB): Promise<string> {
   return await this.getDeviceProperty('persist.sys.country');
 }
 
 /**
- * @this {import('../adb.js').ADB}
- * @return {Promise<string>} Current system locale name on the device under test.
+ * @returns Current system locale name on the device under test.
  */
-export async function getDeviceSysLocale () {
+export async function getDeviceSysLocale (this: ADB): Promise<string> {
   return await this.getDeviceProperty('persist.sys.locale');
 }
 
 /**
- * @this {import('../adb.js').ADB}
- * @return {Promise<string>} Current product language name on the device under test.
+ * @returns Current product language name on the device under test.
  */
-export async function getDeviceProductLanguage () {
+export async function getDeviceProductLanguage (this: ADB): Promise<string> {
   return await this.getDeviceProperty('ro.product.locale.language');
 }
 
 /**
- * @this {import('../adb.js').ADB}
- * @return {Promise<string>} Current product country name on the device under test.
+ * @returns Current product country name on the device under test.
  */
-export async function getDeviceProductCountry () {
+export async function getDeviceProductCountry (this: ADB): Promise<string> {
   return await this.getDeviceProperty('ro.product.locale.region');
 }
 
 /**
- * @this {import('../adb.js').ADB}
- * @return {Promise<string>} Current product locale name on the device under test.
+ * @returns Current product locale name on the device under test.
  */
-export async function getDeviceProductLocale () {
+export async function getDeviceProductLocale (this: ADB): Promise<string> {
   return await this.getDeviceProperty('ro.product.locale');
 }
 
 /**
- * @this {import('../adb.js').ADB}
- * @return {Promise<string>} The model name of the device under test.
+ * @returns The model name of the device under test.
  */
-export async function getModel () {
+export async function getModel (this: ADB): Promise<string> {
   return await this.getDeviceProperty('ro.product.model');
 }
 
 /**
- * @this {import('../adb.js').ADB}
- * @return {Promise<string>} The manufacturer name of the device under test.
+ * @returns The manufacturer name of the device under test.
  */
-export async function getManufacturer () {
+export async function getManufacturer (this: ADB): Promise<string> {
   return await this.getDeviceProperty('ro.product.manufacturer');
 }
 
 /**
  * Get the current screen size.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<string?>} Device screen size as string in format 'WxH' or
+ * @returns Device screen size as string in format 'WxH' or
  * _null_ if it cannot be determined.
  */
-export async function getScreenSize () {
-  let stdout = await this.shell(['wm', 'size']);
-  let size = new RegExp(/Physical size: ([^\r?\n]+)*/g).exec(stdout);
+export async function getScreenSize (this: ADB): Promise<string | null> {
+  const stdout = await this.shell(['wm', 'size']);
+  const size = new RegExp(/Physical size: ([^\r?\n]+)*/g).exec(stdout);
   if (size && size.length >= 2) {
     return size[1].trim();
   }
@@ -133,15 +125,14 @@ export async function getScreenSize () {
 /**
  * Get the current screen density in dpi
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<number?>} Device screen density as a number or _null_ if it
+ * @returns Device screen density as a number or _null_ if it
  * cannot be determined
  */
-export async function getScreenDensity () {
-  let stdout = await this.shell(['wm', 'density']);
-  let density = new RegExp(/Physical density: ([^\r?\n]+)*/g).exec(stdout);
+export async function getScreenDensity (this: ADB): Promise<number | null> {
+  const stdout = await this.shell(['wm', 'density']);
+  const density = new RegExp(/Physical density: ([^\r?\n]+)*/g).exec(stdout);
   if (density && density.length >= 2) {
-    let densityNumber = parseInt(density[1].trim(), 10);
+    const densityNumber = parseInt(density[1].trim(), 10);
     return isNaN(densityNumber) ? null : densityNumber;
   }
   return null;
@@ -151,12 +142,11 @@ export async function getScreenDensity () {
  * Setup HTTP proxy in device global settings.
  * Read https://android.googlesource.com/platform/frameworks/base/+/android-9.0.0_r21/core/java/android/provider/Settings.java for each property
  *
- * @this {import('../adb.js').ADB}
- * @param {string} proxyHost - The host name of the proxy.
- * @param {string|number} proxyPort - The port number to be set.
+ * @param proxyHost - The host name of the proxy.
+ * @param proxyPort - The port number to be set.
  */
-export async function setHttpProxy (proxyHost, proxyPort) {
-  let proxy = `${proxyHost}:${proxyPort}`;
+export async function setHttpProxy (this: ADB, proxyHost: string, proxyPort: string | number): Promise<void> {
+  const proxy = `${proxyHost}:${proxyPort}`;
   if (_.isUndefined(proxyHost)) {
     throw new Error(`Call to setHttpProxy method with undefined proxy_host: ${proxy}`);
   }
@@ -165,7 +155,7 @@ export async function setHttpProxy (proxyHost, proxyPort) {
   }
 
   /** @type {[string, string][]} */
-  const httpProxySettins = [
+  const httpProxySettins: [string, string][] = [
     ['http_proxy', proxy],
     ['global_http_proxy_host', proxyHost],
     ['global_http_proxy_port', `${proxyPort}`]
@@ -178,9 +168,8 @@ export async function setHttpProxy (proxyHost, proxyPort) {
 /**
  * Delete HTTP proxy in device global settings.
  * Rebooting the test device is necessary to apply the change.
- * @this {import('../adb.js').ADB}
  */
-export async function deleteHttpProxy () {
+export async function deleteHttpProxy (this: ADB): Promise<void> {
   const httpProxySettins = [
     'http_proxy',
     'global_http_proxy_host',
@@ -196,13 +185,12 @@ export async function deleteHttpProxy () {
  * Set device property.
  * [android.provider.Settings]{@link https://developer.android.com/reference/android/provider/Settings.html}
  *
- * @this {import('../adb.js').ADB}
- * @param {string} namespace - one of {system, secure, global}, case-insensitive.
- * @param {string} setting - property name.
- * @param {string|number} value - property value.
- * @return {Promise<string>} command output.
+ * @param namespace - one of {system, secure, global}, case-insensitive.
+ * @param setting - property name.
+ * @param value - property value.
+ * @returns command output.
  */
-export async function setSetting (namespace, setting, value) {
+export async function setSetting (this: ADB, namespace: string, setting: string, value: string | number): Promise<string> {
   return await this.shell(['settings', 'put', namespace, setting, `${value}`]);
 }
 
@@ -210,46 +198,45 @@ export async function setSetting (namespace, setting, value) {
  * Get device property.
  * [android.provider.Settings]{@link https://developer.android.com/reference/android/provider/Settings.html}
  *
- * @this {import('../adb.js').ADB}
- * @param {string} namespace - one of {system, secure, global}, case-insensitive.
- * @param {string} setting - property name.
- * @return {Promise<string>} property value.
+ * @param namespace - one of {system, secure, global}, case-insensitive.
+ * @param setting - property name.
+ * @returns property value.
  */
-export async function getSetting (namespace, setting) {
+export async function getSetting (this: ADB, namespace: string, setting: string): Promise<string> {
   return await this.shell(['settings', 'get', namespace, setting]);
 }
 
 /**
  * Get tz database time zone formatted timezone
  *
- * @this {import('../adb.js').ADB}
- * @returns {Promise<string>} TZ database Time Zones format
- * @throws {Error} If any exception is reported by adb shell.
+ * @returns TZ database Time Zones format
+ * @throws If any exception is reported by adb shell.
  */
-export async function getTimeZone () {
+export async function getTimeZone (this: ADB): Promise<string> {
   log.debug('Getting current timezone');
   try {
     return await this.getDeviceProperty('persist.sys.timezone');
   } catch (e) {
-    throw new Error(`Error getting timezone. Original error: ${(/** @type {Error} */ (e)).message}`);
+    const err = e as Error;
+    throw new Error(`Error getting timezone. Original error: ${err.message}`);
   }
 }
 
 /**
  * Retrieve the platform version of the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<string>} The platform version as a string, for example '5.0' for
+ * @returns The platform version as a string, for example '5.0' for
  * Android Lollipop.
  */
-export async function getPlatformVersion () {
+export async function getPlatformVersion (this: ADB): Promise<string> {
   log.info('Getting device platform version');
   try {
     return await this.getDeviceProperty('ro.build.version.release');
   } catch (e) {
+    const err = e as Error;
     throw new Error(
       `Error getting device platform version. ` +
-      `Original error: ${(/**@type {Error} */ (e)).message}`
+      `Original error: ${err.message}`
     );
   }
 }
@@ -258,10 +245,9 @@ export async function getPlatformVersion () {
 /**
  * Retrieve the list of location providers for the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<string[]>} The list of available location providers or an empty list.
+ * @returns The list of available location providers or an empty list.
  */
-export async function getLocationProviders () {
+export async function getLocationProviders (this: ADB): Promise<string[]> {
   if (await this.getApiLevel() < 31) {
     // https://stackoverflow.com/questions/70939503/settings-secure-location-providers-allowed-returns-null-in-android-12
     const stdout = await this.getSetting('secure', 'location_providers_allowed');
@@ -279,10 +265,9 @@ export async function getLocationProviders () {
 /**
  * Toggle the state of GPS location provider.
  *
- * @this {import('../adb.js').ADB}
- * @param {boolean} enabled - Whether to enable (true) or disable (false) the GPS provider.
+ * @param enabled - Whether to enable (true) or disable (false) the GPS provider.
  */
-export async function toggleGPSLocationProvider (enabled) {
+export async function toggleGPSLocationProvider (this: ADB, enabled: boolean): Promise<void> {
   if (await this.getApiLevel() < 31) {
     // https://stackoverflow.com/questions/70939503/settings-secure-location-providers-allowed-returns-null-in-android-12
     await this.setSetting('secure', 'location_providers_allowed', `${enabled ? '+' : '-'}gps`);
@@ -294,10 +279,10 @@ export async function toggleGPSLocationProvider (enabled) {
 /**
  * Decorates an exception message with a solution link
  *
- * @param {Error} e The error object to be decorated
- * @returns {Error} Either the same error or the decorated one
+ * @param e The error object to be decorated
+ * @returns Either the same error or the decorated one
  */
-function decorateWriteSecureSettingsException (e) {
+function decorateWriteSecureSettingsException (e: Error): Error {
   if (_.includes(e.message, 'requires:android.permission.WRITE_SECURE_SETTINGS')) {
     e.message = `Check https://github.com/appium/appium/issues/13802 for throubleshooting. ${e.message}`;
   }
@@ -308,8 +293,7 @@ function decorateWriteSecureSettingsException (e) {
  * Set hidden api policy to manage access to non-SDK APIs.
  * https://developer.android.com/preview/restrictions-non-sdk-interfaces
  *
- * @this {import('../adb.js').ADB}
- * @param {number|string} value - The API enforcement policy.
+ * @param value - The API enforcement policy.
  *     For Android P
  *     0: Disable non-SDK API usage detection. This will also disable logging, and also break the strict mode API,
  *        detectNonSdkApiUsage(). Not recommended.
@@ -327,15 +311,15 @@ function decorateWriteSecureSettingsException (e) {
  *     2: Disallow usage of non-SDK interfaces that belong to either the black list
  *        or to a restricted greylist for your target API level.
  *
- * @param {boolean} [ignoreError=false] Whether to ignore an exception in 'adb shell settings put global' command
- * @throws {error} If there was an error and ignoreError was true while executing 'adb shell settings put global'
+ * @param ignoreError - Whether to ignore an exception in 'adb shell settings put global' command
+ * @throws If there was an error and ignoreError was true while executing 'adb shell settings put global'
  *                 command on the device under test.
  */
-export async function setHiddenApiPolicy (value, ignoreError = false) {
+export async function setHiddenApiPolicy (this: ADB, value: number | string, ignoreError = false): Promise<void> {
   try {
     await this.shell(HIDDEN_API_POLICY_KEYS.map((k) => `settings put global ${k} ${value}`).join(';'));
   } catch (e) {
-    const err = /** @type {Error} */ (e);
+    const err = e as Error;
     if (!ignoreError) {
       throw decorateWriteSecureSettingsException(err);
     }
@@ -350,16 +334,15 @@ export async function setHiddenApiPolicy (value, ignoreError = false) {
  * Reset access to non-SDK APIs to its default setting.
  * https://developer.android.com/preview/restrictions-non-sdk-interfaces
  *
- * @this {import('../adb.js').ADB}
- * @param {boolean} [ignoreError=false] Whether to ignore an exception in 'adb shell settings delete global' command
- * @throws {error} If there was an error and ignoreError was true while executing 'adb shell settings delete global'
+ * @param ignoreError - Whether to ignore an exception in 'adb shell settings delete global' command
+ * @throws If there was an error and ignoreError was true while executing 'adb shell settings delete global'
  *                 command on the device under test.
  */
-export async function setDefaultHiddenApiPolicy (ignoreError = false) {
+export async function setDefaultHiddenApiPolicy (this: ADB, ignoreError = false): Promise<void> {
   try {
     await this.shell(HIDDEN_API_POLICY_KEYS.map((k) => `settings delete global ${k}`).join(';'));
   } catch (e) {
-    const err = /** @type {Error} */ (e);
+    const err = e as Error;
     if (!ignoreError) {
       throw decorateWriteSecureSettingsException(err);
     }
@@ -371,10 +354,9 @@ export async function setDefaultHiddenApiPolicy (ignoreError = false) {
 /**
  * Get the language name of the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<string>} The name of device language.
+ * @returns The name of device language.
  */
-export async function getDeviceLanguage () {
+export async function getDeviceLanguage (this: ADB): Promise<string> {
   return await this.getApiLevel() < 23
     ? (await this.getDeviceSysLanguage() || await this.getDeviceProductLanguage())
     : (await this.getDeviceLocale()).split('-')[0];
@@ -384,10 +366,9 @@ export async function getDeviceLanguage () {
  * Get the country name of the device under test.
  *
  * @summary Could only be used for Android API < 23
- * @this {import('../adb.js').ADB}
- * @return {Promise<string>} The name of device country.
+ * @returns The name of device country.
  */
-export async function getDeviceCountry () {
+export async function getDeviceCountry (this: ADB): Promise<string> {
   return await this.getDeviceSysCountry() || await this.getDeviceProductCountry();
 }
 
@@ -395,25 +376,23 @@ export async function getDeviceCountry () {
  * Get the locale name of the device under test.
  *
  * @summary Could only be used for Android API >= 23
- * @this {import('../adb.js').ADB}
- * @return {Promise<string>} The name of device locale.
+ * @returns The name of device locale.
  */
-export async function getDeviceLocale () {
+export async function getDeviceLocale (this: ADB): Promise<string> {
   return await this.getDeviceSysLocale() || await this.getDeviceProductLocale();
 }
 
 /**
  * Make sure current device locale is expected or not.
  *
- * @this {import('../adb.js').ADB}
  * @privateRemarks FIXME: language or country is required
- * @param {string} [language] - Language. The language field is case insensitive, but Locale always canonicalizes to lower case.
- * @param {string} [country] - Country. The language field is case insensitive, but Locale always canonicalizes to lower case.
- * @param {string} [script] - Script. The script field is case insensitive but Locale always canonicalizes to title case.
+ * @param language - Language. The language field is case insensitive, but Locale always canonicalizes to lower case.
+ * @param country - Country. The language field is case insensitive, but Locale always canonicalizes to lower case.
+ * @param script - Script. The script field is case insensitive but Locale always canonicalizes to title case.
  *
- * @return {Promise<boolean>} If current locale is language and country as arguments, return true.
+ * @returns If current locale is language and country as arguments, return true.
  */
-export async function ensureCurrentLocale (language, country, script) {
+export async function ensureCurrentLocale (this: ADB, language?: string, country?: string, script?: string): Promise<boolean> {
   const hasLanguage = _.isString(language);
   const hasCountry = _.isString(country);
   if (!hasLanguage && !hasCountry) {
@@ -424,10 +403,10 @@ export async function ensureCurrentLocale (language, country, script) {
   const lcLanguage = (language || '').toLowerCase();
   const lcCountry = (country || '').toLowerCase();
   const apiLevel = await this.getApiLevel();
-  return /** @type {boolean} */ (await retryInterval(5, 1000, async () => {
+  return (await retryInterval(5, 1000, async () => {
     if (apiLevel < 23) {
       log.debug(`Requested locale: ${lcLanguage}-${lcCountry}`);
-      let actualLanguage;
+      let actualLanguage: string | undefined;
       if (hasLanguage) {
         actualLanguage = (await this.getDeviceLanguage()).toLowerCase();
         log.debug(`Actual language: ${actualLanguage}`);
@@ -435,7 +414,7 @@ export async function ensureCurrentLocale (language, country, script) {
           return true;
         }
       }
-      let actualCountry;
+      let actualCountry: string | undefined;
       if (hasCountry) {
         actualCountry = (await this.getDeviceCountry()).toLowerCase();
         log.debug(`Actual country: ${actualCountry}`);
@@ -452,7 +431,7 @@ export async function ensureCurrentLocale (language, country, script) {
       : `${lcLanguage}-${lcCountry}`;
     log.debug(`Requested locale: ${expectedLocale}. Actual locale: '${actualLocale}'`);
     const languagePattern = `^${_.escapeRegExp(lcLanguage)}-${script ? (_.escapeRegExp(script) + '-') : ''}`;
-    const checkLocalePattern = (/** @type {string} */ p) => new RegExp(p, 'i').test(actualLocale);
+    const checkLocalePattern = (p: string) => new RegExp(p, 'i').test(actualLocale);
     if (hasLanguage && !hasCountry) {
       return checkLocalePattern(languagePattern);
     }
@@ -461,19 +440,18 @@ export async function ensureCurrentLocale (language, country, script) {
       return checkLocalePattern(countryPattern);
     }
     return [languagePattern, countryPattern].every(checkLocalePattern);
-  }));
+  })) ?? false;
 }
 
 /**
  * Change the state of WiFi on the device under test.
  * Only works for real devices since API 30
  *
- * @this {import('../adb.js').ADB}
- * @param {boolean} on - True to enable and false to disable it.
- * @param {boolean} [isEmulator=false] - Set it to true if the device under test
+ * @param on - True to enable and false to disable it.
+ * @param isEmulator - Set it to true if the device under test
  *                                       is an emulator rather than a real device.
  */
-export async function setWifiState (on, isEmulator = false) {
+export async function setWifiState (this: ADB, on: boolean, isEmulator = false): Promise<void> {
   if (isEmulator) {
     // The svc command does not require to be root since API 26
     await this.shell(['svc', 'wifi', on ? 'enable' : 'disable'], {
@@ -489,12 +467,11 @@ export async function setWifiState (on, isEmulator = false) {
  * Change the state of Data transfer on the device under test.
  * Only works for real devices since API 30
  *
- * @this {import('../adb.js').ADB}
- * @param {boolean} on - True to enable and false to disable it.
- * @param {boolean} [isEmulator=false] - Set it to true if the device under test
+ * @param on - True to enable and false to disable it.
+ * @param isEmulator - Set it to true if the device under test
  *                                       is an emulator rather than a real device.
  */
-export async function setDataState (on, isEmulator = false) {
+export async function setDataState (this: ADB, on: boolean, isEmulator = false): Promise<void> {
   if (isEmulator) {
     // The svc command does not require to be root since API 26
     await this.shell(['svc', 'data', on ? 'enable' : 'disable'], {
@@ -510,13 +487,12 @@ export async function setDataState (on, isEmulator = false) {
 /**
  * Retrieves the list of packages from Doze whitelist on Android 8+
  *
- * @this {import('../adb.js').ADB}
- * @returns {Promise<string[]>} The list of whitelisted packages. An example output:
+ * @returns The list of whitelisted packages. An example output:
  * system,com.android.shell,2000
  * system,com.google.android.cellbroadcastreceiver,10143
  * user,io.appium.settings,10157
  */
-export async function getDeviceIdleWhitelist () {
+export async function getDeviceIdleWhitelist (this: ADB): Promise<string[]> {
   if (await this.getApiLevel() < 23) {
     // Doze mode has only been added since Android 6
     return [];
@@ -532,14 +508,13 @@ export async function getDeviceIdleWhitelist () {
 /**
  * Adds an existing package(s) into the Doze whitelist on Android 8+
  *
- * @this {import('../adb.js').ADB}
- * @param  {...string} packages One or more packages to add. If the package
+ * @param packages One or more packages to add. If the package
  * already exists in the whitelist then it is only going to be added once.
  * If the package with the given name is not installed/not known then an error
  * will be thrown.
- * @returns {Promise<boolean>} `true` if the command to add package(s) has been executed
+ * @returns `true` if the command to add package(s) has been executed
  */
-export async function addToDeviceIdleWhitelist (...packages) {
+export async function addToDeviceIdleWhitelist (this: ADB, ...packages: string[]): Promise<boolean> {
   if (_.isEmpty(packages) || await this.getApiLevel() < 23) {
     // Doze mode has only been added since Android 6
     return false;
@@ -554,10 +529,9 @@ export async function addToDeviceIdleWhitelist (...packages) {
 /**
  * Check the state of Airplane mode on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<boolean>} True if Airplane mode is enabled.
+ * @returns True if Airplane mode is enabled.
  */
-export async function isAirplaneModeOn () {
+export async function isAirplaneModeOn (this: ADB): Promise<boolean> {
   const stdout = await this.getSetting('global', 'airplane_mode_on');
   return parseInt(stdout, 10) !== 0;
   // Alternatively for Android 11+:
@@ -567,10 +541,9 @@ export async function isAirplaneModeOn () {
 /**
  * Change the state of Airplane mode in Settings on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {boolean} on - True to enable the Airplane mode in Settings and false to disable it.
+ * @param on - True to enable the Airplane mode in Settings and false to disable it.
  */
-export async function setAirplaneMode (on) {
+export async function setAirplaneMode (this: ADB, on: boolean): Promise<void> {
   if (await this.getApiLevel() < 30) {
     // This requires to call broadcastAirplaneMode afterwards to apply
     await this.setSetting('global', 'airplane_mode_on', on ? 1 : 0);
@@ -583,10 +556,9 @@ export async function setAirplaneMode (on) {
 /**
  * Change the state of the bluetooth service on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {boolean} on - True to enable bluetooth service and false to disable it.
+ * @param on - True to enable bluetooth service and false to disable it.
  */
-export async function setBluetoothOn (on) {
+export async function setBluetoothOn (this: ADB, on: boolean): Promise<void> {
   if (await this.getApiLevel() < 30) {
     throw new Error('Changing of the bluetooth state is not supported on your device');
   }
@@ -597,14 +569,13 @@ export async function setBluetoothOn (on) {
 /**
  * Change the state of the NFC service on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @param {boolean} on - True to enable NFC service and false to disable it.
- * @throws {Error} If there was an error while changing the service state
+ * @param on - True to enable NFC service and false to disable it.
+ * @throws If there was an error while changing the service state
  */
-export async function setNfcOn (on) {
+export async function setNfcOn (this: ADB, on: boolean): Promise<void> {
   const {stdout, stderr} = await this.shell(['svc', 'nfc', on ? 'enable' : 'disable'], {
     outputFormat: 'full'
-  });
+  }) as {stdout: string; stderr: string};
   const output = stderr || stdout;
   log.debug(output);
   if (output.includes('null NfcAdapter')) {
@@ -622,10 +593,9 @@ export async function setNfcOn (on) {
  * there is a dedicated adb command to change airplane mode state, which
  * does not require to call this one afterwards.
  *
- * @this {import('../adb.js').ADB}
- * @param {boolean} on - True to broadcast enable and false to broadcast disable.
+ * @param on - True to broadcast enable and false to broadcast disable.
  */
-export async function broadcastAirplaneMode (on) {
+export async function broadcastAirplaneMode (this: ADB, on: boolean): Promise<void> {
   const args = [
     'am', 'broadcast',
     '-a', 'android.intent.action.AIRPLANE_MODE',
@@ -634,7 +604,7 @@ export async function broadcastAirplaneMode (on) {
   try {
     await this.shell(args);
   } catch (e) {
-    const err = /** @type {import('teen_process').ExecError} */(e);
+    const err = e as ExecError;
     // https://github.com/appium/appium/issues/17422
     if (_.includes(err.stderr, 'SecurityException')) {
       try {
@@ -649,10 +619,9 @@ export async function broadcastAirplaneMode (on) {
 /**
  * Check the state of WiFi on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<boolean>} True if WiFi is enabled.
+ * @returns True if WiFi is enabled.
  */
-export async function isWifiOn () {
+export async function isWifiOn (this: ADB): Promise<boolean> {
   const stdout = await this.getSetting('global', 'wifi_on');
   return (parseInt(stdout, 10) !== 0);
   // Alternative for Android 11+:
@@ -662,10 +631,9 @@ export async function isWifiOn () {
 /**
  * Check the state of Data transfer on the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<boolean>} True if Data transfer is enabled.
+ * @returns True if Data transfer is enabled.
  */
-export async function isDataOn () {
+export async function isDataOn (this: ADB): Promise<boolean> {
   const stdout = await this.getSetting('global', 'mobile_data');
   return (parseInt(stdout, 10) !== 0);
 }
@@ -676,11 +644,10 @@ export async function isDataOn () {
  *   - transition_animation_scale
  *   - window_animation_scale
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<boolean>} True if at least one of animation scale settings
+ * @returns True if at least one of animation scale settings
  *                   is not equal to '0.0'.
  */
-export async function isAnimationOn () {
+export async function isAnimationOn (this: ADB): Promise<boolean> {
   return (await B.all(ANIMATION_SCALE_KEYS.map(
     async (k) => (await this.getSetting('global', k)) !== '0.0'))
   ).includes(true);
@@ -695,26 +662,23 @@ export async function isAnimationOn () {
  * API level 28+ real devices checked this worked, but we haven't checked older ones
  * with real devices.
  *
- * @this {import('../adb.js').ADB}
- * @param {number} value Animation scale value (int or float) to set.
+ * @param value Animation scale value (int or float) to set.
  *                       The minimum value of zero disables animations.
  *                       By increasing the value, animations become slower.
  *                       '1' is the system default animation scale.
- * @return {Promise<void>}
- * @throws {Error} If the adb setting command raises an exception.
+ * @throws If the adb setting command raises an exception.
  */
-export async function setAnimationScale (value) {
+export async function setAnimationScale (this: ADB, value: number): Promise<void> {
   await B.all(ANIMATION_SCALE_KEYS.map((k) => this.setSetting('global', k, value)));
 }
 
 /**
  * Retrieve current screen orientation of the device under test.
  *
- * @this {import('../adb.js').ADB}
- * @return {Promise<number?>} The current orientation encoded as an integer number.
+ * @returns The current orientation encoded as an integer number.
  */
-export async function getScreenOrientation () {
-  let stdout = await this.shell(['dumpsys', 'input']);
+export async function getScreenOrientation (this: ADB): Promise<number | null> {
+  const stdout = await this.shell(['dumpsys', 'input']);
   return getSurfaceOrientation(stdout);
 }
 
@@ -723,12 +687,12 @@ export async function getScreenOrientation () {
 /**
  * Reads SurfaceOrientation in dumpsys output
  *
- * @param {string} dumpsys
- * @returns {number | null}
+ * @param dumpsys
  */
-function getSurfaceOrientation (dumpsys) {
+function getSurfaceOrientation (dumpsys: string): number | null {
   const m = /SurfaceOrientation: \d/gi.exec(dumpsys);
-  return m && parseInt(m[0].split(':')[1], 10);
+  return m ? parseInt(m[0].split(':')[1], 10) : null;
 }
 
 // #endregion
+