appium-android-driver 7.1.2 → 7.1.4

package/lib/commands/file-actions.js

@@ -85,7 +85,6 @@ function escapePath(p) {
  */
 const FileActionsMixin = {
   async pullFile(remotePath) {
-    const adb = /** @type {ADB} */ (this.adb);
     if (remotePath.endsWith('/')) {
       throw new errors.InvalidArgumentError(
         `It is expected that remote path points to a file and not to a folder. ` +
@@ -100,8 +99,8 @@ const FileActionsMixin = {
       );
       tmpDestination = `/data/local/tmp/${path.posix.basename(pathInContainer)}`;
       try {
-        await adb.shell(['run-as', packageId, `chmod 777 '${escapePath(pathInContainer)}'`]);
-        await adb.shell([
+        await this.adb.shell(['run-as', packageId, `chmod 777 '${escapePath(pathInContainer)}'`]);
+        await this.adb.shell([
           'run-as',
           packageId,
           `cp -f '${escapePath(pathInContainer)}' '${escapePath(tmpDestination)}'`,
@@ -116,14 +115,14 @@ const FileActionsMixin = {
     }
     const localFile = await tempDir.path({prefix: 'appium', suffix: '.tmp'});
     try {
-      await adb.pull(tmpDestination || remotePath, localFile);
+      await this.adb.pull(tmpDestination || remotePath, localFile);
       return (await util.toInMemoryBase64(localFile)).toString();
     } finally {
       if (await fs.exists(localFile)) {
         await fs.unlink(localFile);
       }
       if (tmpDestination) {
-        await adb.shell(['rm', '-f', tmpDestination]);
+        await this.adb.shell(['rm', '-f', tmpDestination]);
       }
     }
   },
@@ -148,7 +147,6 @@ const FileActionsMixin = {
     }
     const content = Buffer.from(base64Data, 'base64');
     let tmpDestination = null;
-    const adb = /** @type {ADB} */ (this.adb);
     try {
       await fs.writeFile(localFile, content.toString('binary'), 'binary');
       if (remotePath.startsWith(CONTAINER_PATH_MARKER)) {
@@ -159,15 +157,15 @@ const FileActionsMixin = {
         );
         tmpDestination = `/data/local/tmp/${path.posix.basename(pathInContainer)}`;
         try {
-          await adb.shell([
+          await this.adb.shell([
             'run-as',
             packageId,
             `mkdir -p '${escapePath(path.posix.dirname(pathInContainer))}'`,
           ]);
-          await adb.shell(['run-as', packageId, `touch '${escapePath(pathInContainer)}'`]);
-          await adb.shell(['run-as', packageId, `chmod 777 '${escapePath(pathInContainer)}'`]);
-          await adb.push(localFile, tmpDestination);
-          await adb.shell([
+          await this.adb.shell(['run-as', packageId, `touch '${escapePath(pathInContainer)}'`]);
+          await this.adb.shell(['run-as', packageId, `chmod 777 '${escapePath(pathInContainer)}'`]);
+          await this.adb.push(localFile, tmpDestination);
+          await this.adb.shell([
             'run-as',
             packageId,
             `cp -f '${escapePath(tmpDestination)}' '${escapePath(pathInContainer)}'`,
@@ -181,18 +179,18 @@ const FileActionsMixin = {
         }
       } else {
         // adb push creates folders and overwrites existing files.
-        await adb.push(localFile, remotePath);
+        await this.adb.push(localFile, remotePath);
 
         // if we have pushed a file, it might be a media file, so ensure that
         // apps know about it
-        await scanMedia(adb, remotePath, this.log);
+        await scanMedia(this.adb, remotePath, this.log);
       }
     } finally {
       if (await fs.exists(localFile)) {
         await fs.unlink(localFile);
       }
       if (tmpDestination) {
-        await adb.shell(['rm', '-f', tmpDestination]);
+        await this.adb.shell(['rm', '-f', tmpDestination]);
       }
     }
   },
@@ -205,7 +203,7 @@ const FileActionsMixin = {
   async pullFolder(remotePath) {
     const tmpRoot = await tempDir.openDir();
     try {
-      await /** @type {ADB} */ (this.adb).pull(remotePath, tmpRoot);
+      await this.adb.pull(remotePath, tmpRoot);
       return (
         await zip.toInMemoryZip(tmpRoot, {
           encodeToBase64: true,
@@ -229,7 +227,7 @@ const FileActionsMixin = {
           `'${remotePath}' is given instead`
       );
     }
-    return await deleteFileOrFolder.call(this, /** @type {ADB} */ (this.adb), remotePath);
+    return await deleteFileOrFolder.call(this, this.adb, remotePath);
   },
 };
 

package/lib/commands/general.js

@@ -41,7 +41,7 @@ const GeneralMixin = {
       'Attempting to capture android device date and time. ' + `The format specifier is '${format}'`
     );
     const deviceTimestamp = (
-      await /** @type {ADB} */ (this.adb).shell(['date', '+%Y-%m-%dT%T%z'])
+      await this.adb.shell(['date', '+%Y-%m-%dT%T%z'])
     ).trim();
     this.log.debug(`Got device timestamp: ${deviceTimestamp}`);
     const parsedTimestamp = moment.utc(deviceTimestamp, 'YYYY-MM-DDTHH:mm:ssZZ');
@@ -66,10 +66,9 @@ const GeneralMixin = {
   },
 
   async openSettingsActivity(setting) {
-    const adb = /** @type {ADB} */ (this.adb);
-    let {appPackage, appActivity} = await adb.getFocusedPackageAndActivity();
-    await adb.shell(['am', 'start', '-a', `android.settings.${setting}`]);
-    await adb.waitForNotActivity(
+    let {appPackage, appActivity} = await this.adb.getFocusedPackageAndActivity();
+    await this.adb.shell(['am', 'start', '-a', `android.settings.${setting}`]);
+    await this.adb.waitForNotActivity(
       /** @type {string} */ (appPackage),
       /** @type {string} */ (appActivity),
       5000
@@ -95,26 +94,25 @@ const GeneralMixin = {
    * @returns {Promise<string>}
    */
   async getCurrentActivity() {
-    return /** @type {string} */ ((await /** @type {ADB} */ (this.adb).getFocusedPackageAndActivity()).appActivity);
+    return /** @type {string} */ ((await this.adb.getFocusedPackageAndActivity()).appActivity);
   },
 
   /**
    * @returns {Promise<string>}
    */
   async getCurrentPackage() {
-    return /** @type {string} */ ((await /** @type {ADB} */ (this.adb).getFocusedPackageAndActivity()).appPackage);
+    return /** @type {string} */ ((await this.adb.getFocusedPackageAndActivity()).appPackage);
   },
 
   async background(seconds) {
-    const adb = /** @type {ADB} */ (this.adb);
     if (seconds < 0) {
       // if user passes in a negative seconds value, interpret that as the instruction
       // to not bring the app back at all
-      await adb.goToHome();
+      await this.adb.goToHome();
       return true;
     }
-    let {appPackage, appActivity} = await adb.getFocusedPackageAndActivity();
-    await adb.goToHome();
+    let {appPackage, appActivity} = await this.adb.getFocusedPackageAndActivity();
+    await this.adb.goToHome();
 
     // people can wait for a long time, so to be safe let's use the longSleep function and log
     // progress periodically.
@@ -178,13 +176,12 @@ const GeneralMixin = {
     this.log.debug(
       `Bringing application back to foreground with arguments: ${JSON.stringify(args)}`
     );
-    return await adb.startApp(args);
+    return await this.adb.startApp(args);
   },
 
   async getStrings(language) {
-    const adb = /** @type {ADB} */ (this.adb);
     if (!language) {
-      language = await adb.getDeviceLanguage();
+      language = await this.adb.getDeviceLanguage();
       this.log.info(`No language specified, returning strings for: ${language}`);
     }
 
@@ -205,7 +202,7 @@ const GeneralMixin = {
       return preprocessStringsMap(this.apkStrings[language]);
     }
 
-    this.apkStrings[language] = await androidHelpers.pushStrings(language, adb, this.opts);
+    this.apkStrings[language] = await androidHelpers.pushStrings(language, this.adb, this.opts);
 
     return preprocessStringsMap(this.apkStrings[language]);
   },
@@ -247,12 +244,12 @@ const GeneralMixin = {
     };
     this._cachedActivityArgs = this._cachedActivityArgs || {};
     this._cachedActivityArgs[`${args.waitPkg}/${args.waitActivity}`] = args;
-    await /** @type {ADB} */ (this.adb).startApp(args);
+    await this.adb.startApp(args);
   },
 
   async reset() {
     await androidHelpers.resetApp(
-      /** @type {ADB} */ (this.adb),
+      this.adb,
       Object.assign({}, this.opts, {fastReset: true})
     );
     // reset context since we don't know what kind on context we will end up after app launch.
@@ -261,7 +258,7 @@ const GeneralMixin = {
   },
 
   async startAUT() {
-    await /** @type {ADB} */ (this.adb).startApp({
+    await this.adb.startApp({
       pkg: /** @type {string} */ (this.opts.appPackage),
       activity: this.opts.appActivity,
       action: this.opts.intentAction,
@@ -280,19 +277,19 @@ const GeneralMixin = {
   // we override setUrl to take an android URI which can be used for deep-linking
   // inside an app, similar to starting an intent
   async setUrl(uri) {
-    await /** @type {ADB} */ (this.adb).startUri(uri, /** @type {string} */ (this.opts.appPackage));
+    await this.adb.startUri(uri, /** @type {string} */ (this.opts.appPackage));
   },
 
   // closing app using force stop
   async closeApp() {
-    await /** @type {ADB} */ (this.adb).forceStop(/** @type {string} */ (this.opts.appPackage));
+    await this.adb.forceStop(/** @type {string} */ (this.opts.appPackage));
     // reset context since we don't know what kind on context we will end up after app launch.
     await this.setContext();
   },
 
   async getDisplayDensity() {
     // first try the property for devices
-    let out = await /** @type {ADB} */ (this.adb).shell(['getprop', 'ro.sf.lcd_density']);
+    let out = await this.adb.shell(['getprop', 'ro.sf.lcd_density']);
     if (out) {
       let val = parseInt(out, 10);
       // if the value is NaN, try getting the emulator property
@@ -302,7 +299,7 @@ const GeneralMixin = {
       this.log.debug(`Parsed density value was NaN: "${out}"`);
     }
     // fallback to trying property for emulators
-    out = await /** @type {ADB} */ (this.adb).shell(['getprop', 'qemu.sf.lcd_density']);
+    out = await this.adb.shell(['getprop', 'qemu.sf.lcd_density']);
     if (out) {
       let val = parseInt(out, 10);
       if (!isNaN(val)) {
@@ -317,15 +314,15 @@ const GeneralMixin = {
 
   async mobilePerformEditorAction(opts) {
     const {action} = requireArgs('action', opts);
-    await /** @type {ADB} */ (this.adb).performEditorAction(action);
+    await this.adb.performEditorAction(action);
   },
 
   async mobileGetNotifications() {
-    return await /** @type {ADB} */ (this.adb).getNotifications();
+    return await this.adb.getNotifications();
   },
 
   async mobileListSms(opts) {
-    return await /** @type {ADB} */ (this.adb).getSmsList(opts);
+    return await this.adb.getSmsList(opts);
   },
 
   async mobileUnlock(opts = {}) {
@@ -334,7 +331,7 @@ const GeneralMixin = {
       await this.unlock();
     } else {
       // @ts-expect-error XXX: these caps should be defined in the constraints!!
-      await androidHelpers.unlock(this, /** @type {ADB} */ (this.adb), {
+      await androidHelpers.unlock(this, this.adb, {
         unlockKey: key,
         unlockType: type,
         unlockStrategy: strategy,

package/lib/commands/ime.js

@@ -16,27 +16,26 @@ const IMEMixin = {
 
   async availableIMEEngines() {
     this.log.debug('Retrieving available IMEs');
-    let engines = await /** @type {ADB} */ (this.adb).availableIMEs();
+    let engines = await this.adb.availableIMEs();
     this.log.debug(`Engines: ${JSON.stringify(engines)}`);
     return engines;
   },
 
   async getActiveIMEEngine() {
     this.log.debug('Retrieving current default IME');
-    return String(await /** @type {ADB} */ (this.adb).defaultIME());
+    return String(await this.adb.defaultIME());
   },
 
   async activateIMEEngine(imeId) {
-    const adb = /** @type {ADB} */ (this.adb);
     this.log.debug(`Attempting to activate IME ${imeId}`);
-    let availableEngines = await adb.availableIMEs();
+    let availableEngines = await this.adb.availableIMEs();
     if (availableEngines.indexOf(imeId) === -1) {
       this.log.debug('IME not found, failing');
       throw new errors.IMENotAvailableError();
     }
     this.log.debug('Found installed IME, attempting to activate');
-    await adb.enableIME(imeId);
-    await adb.setIME(imeId);
+    await this.adb.enableIME(imeId);
+    await this.adb.setIME(imeId);
   },
 
   async deactivateIMEEngine() {
@@ -44,7 +43,7 @@ const IMEMixin = {
     // XXX: this allowed 'null' to be passed into `adb.shell`
     if (currentEngine) {
       this.log.debug(`Attempting to deactivate ${currentEngine}`);
-      await /** @type {ADB} */ (this.adb).disableIME(currentEngine);
+      await this.adb.disableIME(currentEngine);
     }
   },
 };

package/lib/commands/intent.js

@@ -108,7 +108,7 @@ const ActivityMixin = {
     const {user, wait, stop, windowingMode, activityType, display} = opts;
     const cmd = [
       'am',
-      (await /** @type {ADB} */ (this.adb).getApiLevel()) < API_LEVEL_ANDROID_8
+      (await this.adb.getApiLevel()) < API_LEVEL_ANDROID_8
         ? 'start'
         : 'start-activity',
     ];
@@ -131,7 +131,7 @@ const ActivityMixin = {
       cmd.push('--display', String(display));
     }
     cmd.push(...parseIntentSpec(opts));
-    return await /** @type {ADB} */ (this.adb).shell(cmd);
+    return await this.adb.shell(cmd);
   },
 
   async mobileBroadcast(opts = {}) {
@@ -147,13 +147,13 @@ const ActivityMixin = {
       cmd.push('--allow-background-activity-starts');
     }
     cmd.push(...parseIntentSpec(opts));
-    return await /** @type {ADB} */ (this.adb).shell(cmd);
+    return await this.adb.shell(cmd);
   },
 
   async mobileStartService(opts = {}) {
     const {user, foreground} = opts;
     const cmd = ['am'];
-    if ((await /** @type {ADB} */ (this.adb).getApiLevel()) < API_LEVEL_ANDROID_8) {
+    if ((await this.adb.getApiLevel()) < API_LEVEL_ANDROID_8) {
       cmd.push('startservice');
     } else {
       cmd.push(foreground ? 'start-foreground-service' : 'start-service');
@@ -162,14 +162,14 @@ const ActivityMixin = {
       cmd.push('--user', String(user));
     }
     cmd.push(...parseIntentSpec(opts));
-    return await /** @type {ADB} */ (this.adb).shell(cmd);
+    return await this.adb.shell(cmd);
   },
 
   async mobileStopService(opts = {}) {
     const {user} = opts;
     const cmd = [
       'am',
-      (await /** @type {ADB} */ (this.adb).getApiLevel()) < API_LEVEL_ANDROID_8
+      (await this.adb.getApiLevel()) < API_LEVEL_ANDROID_8
         ? 'stopservice'
         : 'stop-service',
     ];
@@ -177,7 +177,7 @@ const ActivityMixin = {
       cmd.push('--user', String(user));
     }
     cmd.push(...parseIntentSpec(opts));
-    return await /** @type {ADB} */ (this.adb).shell(cmd);
+    return await this.adb.shell(cmd);
   },
 };
 

package/lib/commands/log.js

@@ -91,7 +91,6 @@ const LogMixin = {
    */
   async mobileStartLogsBroadcast() {
     const server = /** @type {import('@appium/types').AppiumServer} */ (this.server);
-    const adb = /** @type {ADB} */ (this.adb);
     const pathname = WEBSOCKET_ENDPOINT(/** @type {string} */ (this.sessionId));
     if (!_.isEmpty(await server.getWebSocketHandlers(pathname))) {
       log.debug(`The logcat broadcasting web socket server is already listening at ${pathname}`);
@@ -123,12 +122,12 @@ const LogMixin = {
           }
         };
       }
-      adb.setLogcatListener(this._logcatWebsocketListener);
+      this.adb.setLogcatListener(this._logcatWebsocketListener);
 
       ws.on('close', (code, reason) => {
         if (!_.isEmpty(this._logcatWebsocketListener)) {
           try {
-            adb.removeLogcatListener(this._logcatWebsocketListener);
+            this.adb.removeLogcatListener(this._logcatWebsocketListener);
           } catch (ign) {}
           this._logcatWebsocketListener = undefined;
         }

package/lib/commands/media-projection.js

@@ -191,11 +191,10 @@ class MediaProjectionRecorder {
  */
 const MediaProjectionMixin = {
   async mobileStartMediaProjectionRecording(options = {}) {
-    const adb = /** @type {ADB} */ (this.adb);
-    await verifyMediaProjectionRecordingIsSupported(adb);
+    await verifyMediaProjectionRecordingIsSupported(this.adb);
 
     const {resolution, priority, maxDurationSec, filename} = options;
-    const recorder = new MediaProjectionRecorder(adb);
+    const recorder = new MediaProjectionRecorder(this.adb);
     const fname = adjustMediaExtension(filename || moment().format(DEFAULT_FILENAME_FORMAT));
     const didStart = await recorder.start({
       resolution,
@@ -214,18 +213,16 @@ const MediaProjectionMixin = {
   },
 
   async mobileIsMediaProjectionRecordingRunning() {
-    const adb = /** @type {ADB} */ (this.adb);
-    await verifyMediaProjectionRecordingIsSupported(adb);
+    await verifyMediaProjectionRecordingIsSupported(this.adb);
 
-    const recorder = new MediaProjectionRecorder(adb);
+    const recorder = new MediaProjectionRecorder(this.adb);
     return await recorder.isRunning();
   },
 
   async mobileStopMediaProjectionRecording(options = {}) {
-    const adb = /** @type {ADB} */ (this.adb);
-    await verifyMediaProjectionRecordingIsSupported(adb);
+    await verifyMediaProjectionRecordingIsSupported(this.adb);
 
-    const recorder = new MediaProjectionRecorder(adb);
+    const recorder = new MediaProjectionRecorder(this.adb);
     if (await recorder.stop()) {
       this.log.info(
         'Successfully stopped a media projection recording. Pulling the recorded media'

package/lib/commands/network.js

@@ -30,16 +30,15 @@ const SUPPORTED_SERVICE_NAMES = /** @type {const} */ ([
  */
 const NetworkMixin = {
   async getNetworkConnection() {
-    const adb = /** @type {ADB} */ (this.adb);
     this.log.info('Getting network connection');
-    let airplaneModeOn = await adb.isAirplaneModeOn();
+    let airplaneModeOn = await this.adb.isAirplaneModeOn();
     let connection = airplaneModeOn ? AIRPLANE_MODE_MASK : 0;
 
     // no need to check anything else if we are in airplane mode
     if (!airplaneModeOn) {
       let wifiOn = await this.isWifiOn();
       connection |= wifiOn ? WIFI_MASK : 0;
-      let dataOn = await adb.isDataOn();
+      let dataOn = await this.adb.isDataOn();
       connection |= dataOn ? DATA_MASK : 0;
     }
 
@@ -47,12 +46,11 @@ const NetworkMixin = {
   },
 
   async isWifiOn() {
-    return await /** @type {ADB} */ (this.adb).isWifiOn();
+    return await this.adb.isWifiOn();
   },
 
   async mobileSetConnectivity(opts = {}) {
     const {wifi, data, airplaneMode} = opts;
-    const adb = /** @type {ADB} */ (this.adb);
     if (_.every([wifi, data, airplaneMode], _.isUndefined)) {
       throw new errors.InvalidArgumentError(
         `Either one of ${JSON.stringify(SUPPORTED_SERVICE_NAMES)} options must be provided`
@@ -69,16 +67,16 @@ const NetworkMixin = {
     /** @type {(Promise<any>|(() => Promise<any>))[]} */
     const setters = [];
     if (!_.isUndefined(wifi) && currentState.wifi !== Boolean(wifi)) {
-      setters.push(adb.setWifiState(wifi, this.isEmulator()));
+      setters.push(this.adb.setWifiState(wifi, this.isEmulator()));
     }
     if (!_.isUndefined(data) && currentState.data !== Boolean(data)) {
-      setters.push(adb.setDataState(data, this.isEmulator()));
+      setters.push(this.adb.setDataState(data, this.isEmulator()));
     }
     if (!_.isUndefined(airplaneMode) && currentState.airplaneMode !== Boolean(airplaneMode)) {
       setters.push(async () => {
-        await adb.setAirplaneMode(airplaneMode);
-        if ((await adb.getApiLevel()) < 30) {
-          await adb.broadcastAirplaneMode(airplaneMode);
+        await this.adb.setAirplaneMode(airplaneMode);
+        if ((await this.adb.getApiLevel()) < 30) {
+          await this.adb.broadcastAirplaneMode(airplaneMode);
         }
       });
     }
@@ -104,13 +102,12 @@ const NetworkMixin = {
           `suported: ${SUPPORTED_SERVICE_NAMES}`
       );
     }
-    const adb = /** @type {ADB} */ (this.adb);
 
     const statePromises = {
-      wifi: B.resolve(svcs.includes(WIFI_KEY_NAME) ? adb.isWifiOn() : undefined),
-      data: B.resolve(svcs.includes(DATA_KEY_NAME) ? adb.isDataOn() : undefined),
+      wifi: B.resolve(svcs.includes(WIFI_KEY_NAME) ? this.adb.isWifiOn() : undefined),
+      data: B.resolve(svcs.includes(DATA_KEY_NAME) ? this.adb.isDataOn() : undefined),
       airplaneMode: B.resolve(
-        svcs.includes(AIRPLANE_MODE_KEY_NAME) ? adb.isAirplaneModeOn() : undefined
+        svcs.includes(AIRPLANE_MODE_KEY_NAME) ? this.adb.isAirplaneModeOn() : undefined
       ),
     };
     await B.all(_.values(statePromises));
@@ -133,11 +130,10 @@ const NetworkMixin = {
     const isWiFiEnabled = (currentState & WIFI_MASK) !== 0;
     const isDataEnabled = (currentState & DATA_MASK) !== 0;
 
-    const adb = /** @type {ADB} */ (this.adb);
     if (shouldEnableAirplaneMode !== isAirplaneModeEnabled) {
-      await adb.setAirplaneMode(shouldEnableAirplaneMode);
-      if ((await adb.getApiLevel()) < 30) {
-        await adb.broadcastAirplaneMode(shouldEnableAirplaneMode);
+      await this.adb.setAirplaneMode(shouldEnableAirplaneMode);
+      if ((await this.adb.getApiLevel()) < 30) {
+        await this.adb.broadcastAirplaneMode(shouldEnableAirplaneMode);
       }
     } else {
       this.log.info(
@@ -151,7 +147,7 @@ const NetworkMixin = {
       this.log.info(
         'Not changing data connection/Wi-Fi states, since they are already set to expected values'
       );
-      if (await adb.isAirplaneModeOn()) {
+      if (await this.adb.isAirplaneModeOn()) {
         return AIRPLANE_MODE_MASK | currentState;
       }
       return ~AIRPLANE_MODE_MASK & currentState;
@@ -174,46 +170,43 @@ const NetworkMixin = {
           `${shouldEnableDataConnection ? 'enabled' : 'disabled'}`
       );
     } else {
-      await adb.setDataState(shouldEnableDataConnection, this.isEmulator());
+      await this.adb.setDataState(shouldEnableDataConnection, this.isEmulator());
     }
 
     return await this.getNetworkConnection();
   },
 
   async setWifiState(wifi) {
-    await /** @type {ADB} */ (this.adb).setWifiState(wifi, this.isEmulator());
+    await this.adb.setWifiState(wifi, this.isEmulator());
   },
 
   async toggleData() {
-    const adb = /** @type {ADB} */ (this.adb);
-    let data = !(await adb.isDataOn());
+    let data = !(await this.adb.isDataOn());
     this.log.info(`Turning network data ${data ? 'on' : 'off'}`);
-    await adb.setWifiAndData({data}, this.isEmulator());
+    await this.adb.setWifiAndData({data}, this.isEmulator());
   },
 
   async toggleWiFi() {
-    const adb = /** @type {ADB} */ (this.adb);
-    let wifi = !(await adb.isWifiOn());
+    let wifi = !(await this.adb.isWifiOn());
     this.log.info(`Turning WiFi ${wifi ? 'on' : 'off'}`);
-    await adb.setWifiAndData({wifi}, this.isEmulator());
+    await this.adb.setWifiAndData({wifi}, this.isEmulator());
   },
 
   async toggleFlightMode() {
-    const adb = /** @type {ADB} */ (this.adb);
     /*
      * TODO: Implement isRealDevice(). This method fails on
      * real devices, it should throw a NotYetImplementedError
      */
-    let flightMode = !(await adb.isAirplaneModeOn());
+    let flightMode = !(await this.adb.isAirplaneModeOn());
     this.log.info(`Turning flight mode ${flightMode ? 'on' : 'off'}`);
-    await adb.setAirplaneMode(flightMode);
-    if ((await adb.getApiLevel()) < 30) {
-      await adb.broadcastAirplaneMode(flightMode);
+    await this.adb.setAirplaneMode(flightMode);
+    if ((await this.adb.getApiLevel()) < 30) {
+      await this.adb.broadcastAirplaneMode(flightMode);
     }
   },
 
   async setGeoLocation(location) {
-    await /** @type {ADB} */ (this.adb).setGeoLocation(location, this.isEmulator());
+    await this.adb.setGeoLocation(location, this.isEmulator());
     try {
       return await this.getGeoLocation();
     } catch (e) {
@@ -231,11 +224,11 @@ const NetworkMixin = {
 
   async mobileRefreshGpsCache(opts = {}) {
     const {timeoutMs} = opts;
-    await /** @type {ADB} */ (this.adb).refreshGeoLocationCache(timeoutMs);
+    await this.adb.refreshGeoLocationCache(timeoutMs);
   },
 
   async getGeoLocation() {
-    const {latitude, longitude, altitude} = await /** @type {ADB} */ (this.adb).getGeoLocation();
+    const {latitude, longitude, altitude} = await this.adb.getGeoLocation();
     return {
       latitude: parseFloat(String(latitude)) || GEO_EPSILON,
       longitude: parseFloat(String(longitude)) || GEO_EPSILON,
@@ -244,7 +237,7 @@ const NetworkMixin = {
   },
 
   async isLocationServicesEnabled() {
-    return (await /** @type {ADB} */ (this.adb).getLocationProviders()).includes('gps');
+    return (await this.adb.getLocationProviders()).includes('gps');
   },
 
   async toggleLocationServices() {
@@ -254,7 +247,7 @@ const NetworkMixin = {
       `Current GPS state: ${isGpsEnabled}. ` +
         `The service is going to be ${isGpsEnabled ? 'disabled' : 'enabled'}`
     );
-    await /** @type {ADB} */ (this.adb).toggleGPSLocationProvider(!isGpsEnabled);
+    await this.adb.toggleGPSLocationProvider(!isGpsEnabled);
   },
 };
 

package/lib/commands/performance.js

@@ -163,12 +163,12 @@ async function getMemoryInfo(packageName, retries = 2) {
       `'${MEMINFO_TITLES.NATIVE}|${MEMINFO_TITLES.DALVIK}|${MEMINFO_TITLES.EGL}` +
         `|${MEMINFO_TITLES.GL}|${MEMINFO_TITLES.TOTAL}'`,
     ];
-    const data = await /** @type {ADB} */ (this.adb).shell(cmd);
+    const data = await this.adb.shell(cmd);
     if (!data) {
       throw new Error('No data from dumpsys');
     }
     const valDict = {totalPrivateDirty: ''};
-    const apiLevel = await /** @type {ADB} */ (this.adb).getApiLevel();
+    const apiLevel = await this.adb.getApiLevel();
     for (const line of data.split('\n')) {
       const entries = line.trim().split(/\s+/).filter(Boolean);
       if (apiLevel >= 30) {
@@ -199,7 +199,7 @@ async function getNetworkTrafficInfo(retries = 2) {
     let bucketDuration, bucketStart, activeTime, rxBytes, rxPackets, txBytes, txPackets, operations;
 
     let cmd = ['dumpsys', 'netstats'];
-    let data = await /** @type {ADB} */ (this.adb).shell(cmd);
+    let data = await this.adb.shell(cmd);
     if (!data) throw new Error('No data from dumpsys'); //eslint-disable-line curly
 
     // In case of network traffic information, it is different for the return data between emulator and real device.
@@ -389,7 +389,7 @@ async function getCPUInfo(packageName, retries = 2) {
     /** @type {string} */
     let output;
     try {
-      output = await /** @type {ADB} */ (this.adb).shell(['dumpsys', 'cpuinfo']);
+      output = await this.adb.shell(['dumpsys', 'cpuinfo']);
     } catch (e) {
       const err = /** @type {import('teen_process').ExecError} */ (e);
       if (err.stderr) {
@@ -423,7 +423,7 @@ async function getCPUInfo(packageName, retries = 2) {
 async function getBatteryInfo(retries = 2) {
   return await retryInterval(retries, RETRY_PAUSE_MS, async () => {
     let cmd = ['dumpsys', 'battery', '|', 'grep', 'level'];
-    let data = await /** @type {ADB} */ (this.adb).shell(cmd);
+    let data = await this.adb.shell(cmd);
     if (!data) throw new Error('No data from dumpsys'); //eslint-disable-line curly
 
     let power = parseInt((data.split(':')[1] || '').trim(), 10);