appium-android-driver 14.0.1 → 14.0.3

package/lib/commands/device/utils.ts

@@ -1,15 +1,11 @@
 import {util} from '@appium/support';
 import {ADB} from 'appium-adb';
 import {retryInterval} from 'asyncbox';
-import {
-  path as SETTINGS_APK_PATH,
-  SETTINGS_HELPER_ID,
-  UNICODE_IME,
-  EMPTY_IME,
-} from 'io.appium.settings';
-import {prepareEmulatorForImageInjection} from '../image-injection.js';
-import {ADB_LISTEN_ALL_NETWORK_FEATURE} from '../../utils.js';
+import {path as SETTINGS_APK_PATH, SETTINGS_HELPER_ID, UNICODE_IME, EMPTY_IME} from 'io.appium.settings';
+
 import type {AndroidDriver} from '../../driver.js';
+import {ADB_LISTEN_ALL_NETWORK_FEATURE} from '../../utils.js';
+import {prepareEmulatorForImageInjection} from '../image-injection.js';
 
 const HELPER_APP_INSTALL_RETRIES = 3;
 const HELPER_APP_INSTALL_RETRY_DELAY_MS = 5000;
@@ -55,7 +51,7 @@ export function prepareAvdArgs(this: AndroidDriver): string[] {
     if (Array.isArray(avdArgs)) {
       result.push(...avdArgs);
     } else {
-      result.push(...util.shellParse(`${avdArgs}`));
+      result.push(...util.shellParse(`${avdArgs}`).filter((entry): entry is string => typeof entry === 'string'));
     }
   }
   if (networkSpeed) {
@@ -97,10 +93,7 @@ export async function prepareEmulator(this: AndroidDriver, adb: ADB): Promise<vo
   }
   const args = prepareAvdArgs.bind(this)();
   if (isEmulatorRunning) {
-    if (
-      (await prepareEmulatorForImageInjection.bind(this)(adb.sdkRoot as string)) ||
-      args.includes('-wipe-data')
-    ) {
+    if ((await prepareEmulatorForImageInjection.bind(this)(adb.sdkRoot as string)) || args.includes('-wipe-data')) {
       this.log.debug(`Killing '${avdName}'`);
       await adb.killEmulator(avdName);
     } else {
@@ -203,9 +196,7 @@ export async function pushSettingsApp(this: AndroidDriver, throwIfError: boolean
   // Reinstall would stop the settings helper process anyway, so
   // there is no need to continue if the application is still running
   if (await this.settingsApp.isRunningInForeground()) {
-    this.log.debug(
-      `${SETTINGS_HELPER_ID} is already running. ` + `There is no need to reset its permissions.`,
-    );
+    this.log.debug(`${SETTINGS_HELPER_ID} is already running. There is no need to reset its permissions.`);
     return;
   }
 

package/lib/commands/deviceidle.ts

@@ -1,4 +1,5 @@
 import {errors} from 'appium/driver.js';
+
 import type {AndroidDriver} from '../driver.js';
 
 const SUPPORTED_ACTIONS = ['whitelistAdd', 'whitelistRemove'] as const;

package/lib/commands/element.ts

@@ -1,7 +1,8 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
-import {errors} from 'appium/driver.js';
 import type {Position, Size} from '@appium/types';
+import {errors} from 'appium/driver.js';
+
 import type {AndroidDriver} from '../driver.js';
 import type {DoSetElementValueOpts} from './types.js';
 
@@ -13,11 +14,7 @@ import type {DoSetElementValueOpts} from './types.js';
  * @returns Promise that resolves to the attribute value, or `null` if not found.
  * @throws {errors.NotImplementedError} This method is not implemented.
  */
-export async function getAttribute(
-  this: AndroidDriver,
-  attribute: string,
-  elementId: string,
-): Promise<string | null> {
+export async function getAttribute(this: AndroidDriver, attribute: string, elementId: string): Promise<string | null> {
   throw new errors.NotImplementedError('Not implemented');
 }
 
@@ -139,10 +136,7 @@ export async function setElementValue(
  * @returns Promise that resolves when the value is set.
  * @throws {errors.NotImplementedError} This method is not implemented.
  */
-export async function doSetElementValue(
-  this: AndroidDriver,
-  params: DoSetElementValueOpts,
-): Promise<void> {
+export async function doSetElementValue(this: AndroidDriver, params: DoSetElementValueOpts): Promise<void> {
   throw new errors.NotImplementedError('Not implemented');
 }
 
@@ -153,11 +147,7 @@ export async function doSetElementValue(
  * @param elementId The element identifier.
  * @returns Promise that resolves when the value is set.
  */
-export async function setValue(
-  this: AndroidDriver,
-  keys: string | string[],
-  elementId: string,
-): Promise<void> {
+export async function setValue(this: AndroidDriver, keys: string | string[], elementId: string): Promise<void> {
   return await this.setElementValue(keys, elementId, false);
 }
 
@@ -168,11 +158,7 @@ export async function setValue(
  * @param elementId The element identifier.
  * @returns Promise that resolves when the value is replaced.
  */
-export async function replaceValue(
-  this: AndroidDriver,
-  keys: string | string[],
-  elementId: string,
-): Promise<void> {
+export async function replaceValue(this: AndroidDriver, keys: string | string[], elementId: string): Promise<void> {
   return await this.setElementValue(keys, elementId, true);
 }
 

package/lib/commands/execute.ts

@@ -1,8 +1,9 @@
-import {errors, PROTOCOLS} from 'appium/driver.js';
 import {util} from '@appium/support';
 import type {StringRecord, Element} from '@appium/types';
-import type {AndroidDriver} from '../driver.js';
 import type {Chromedriver} from 'appium-chromedriver';
+import {errors, PROTOCOLS} from 'appium/driver.js';
+
+import type {AndroidDriver} from '../driver.js';
 
 const EXECUTE_SCRIPT_PREFIX = 'mobile:';
 
@@ -17,11 +18,7 @@ type ExecuteMethodArgs = readonly any[] | readonly [StringRecord] | Readonly<Str
  * @returns Promise that resolves to the script execution result.
  * @throws {errors.NotImplementedError} If not in a web context and script doesn't start with 'mobile:'.
  */
-export async function execute(
-  this: AndroidDriver,
-  script: string,
-  args?: ExecuteMethodArgs,
-): Promise<any> {
+export async function execute(this: AndroidDriver, script: string, args?: ExecuteMethodArgs): Promise<any> {
   if (script?.startsWith(EXECUTE_SCRIPT_PREFIX)) {
     const formattedScript = script.trim().replace(/^mobile:\s*/, `${EXECUTE_SCRIPT_PREFIX} `);
     const executeMethodArgs = preprocessExecuteMethodArgs(args);
@@ -31,9 +28,7 @@ export async function execute(
     throw new errors.NotImplementedError();
   }
   const endpoint =
-    (this.chromedriver as Chromedriver).jwproxy.downstreamProtocol === PROTOCOLS.MJSONWP
-      ? '/execute'
-      : '/execute/sync';
+    (this.chromedriver as Chromedriver).jwproxy.downstreamProtocol === PROTOCOLS.MJSONWP ? '/execute' : '/execute/sync';
   return await (this.chromedriver as Chromedriver).jwproxy.command(endpoint, 'POST', {
     script,
     args,
@@ -62,9 +57,7 @@ function preprocessExecuteMethodArgs(args?: ExecuteMethodArgs): StringRecord {
    * Automatically unwraps the `elementId` prop _if and only if_ the execute method expects it.
    */
   if ('elementId' in executeMethodArgs) {
-    executeMethodArgs.elementId = util.unwrapElement(
-      executeMethodArgs.elementId as Element | string,
-    );
+    executeMethodArgs.elementId = util.unwrapElement(executeMethodArgs.elementId as Element | string);
   }
 
   return executeMethodArgs;

package/lib/commands/file-actions.ts

@@ -1,8 +1,10 @@
-import {fs, util, zip, tempDir} from '@appium/support';
 import path from 'node:path';
+
+import {fs, util, zip, tempDir} from '@appium/support';
+import type {ADB} from 'appium-adb';
 import {errors} from 'appium/driver.js';
+
 import type {AndroidDriver} from '../driver.js';
-import type {ADB} from 'appium-adb';
 
 const CONTAINER_PATH_MARKER = '@';
 // https://regex101.com/r/PLdB0G/2
@@ -27,8 +29,7 @@ const ANDROID_MEDIA_RESCAN_INTENT = 'android.intent.action.MEDIA_SCANNER_SCAN_FI
 export async function pullFile(this: AndroidDriver, remotePath: string): Promise<string> {
   if (remotePath.endsWith('/')) {
     throw new errors.InvalidArgumentError(
-      `It is expected that remote path points to a file and not to a folder. ` +
-        `'${remotePath}' is given instead`,
+      `It is expected that remote path points to a file and not to a folder. '${remotePath}' is given instead`,
     );
   }
   let tmpDestination: string | null = null;
@@ -84,15 +85,10 @@ export async function pullFile(this: AndroidDriver, remotePath: string): Promise
  * @returns Promise that resolves when the file is pushed.
  * @throws {errors.InvalidArgumentError} If the remote path points to a folder instead of a file.
  */
-export async function pushFile(
-  this: AndroidDriver,
-  remotePath: string,
-  base64Data: string | number[],
-): Promise<void> {
+export async function pushFile(this: AndroidDriver, remotePath: string, base64Data: string | number[]): Promise<void> {
   if (remotePath.endsWith('/')) {
     throw new errors.InvalidArgumentError(
-      `It is expected that remote path points to a file and not to a folder. ` +
-        `'${remotePath}' is given instead`,
+      `It is expected that remote path points to a file and not to a folder. '${remotePath}' is given instead`,
     );
   }
   const localFile = await tempDir.path({prefix: 'appium', suffix: '.tmp'});
@@ -116,11 +112,7 @@ export async function pushFile(
       );
       tmpDestination = `/data/local/tmp/${path.posix.basename(pathInContainer)}`;
       try {
-        await this.adb.shell([
-          'run-as',
-          packageId,
-          `mkdir -p '${escapePath(path.posix.dirname(pathInContainer))}'`,
-        ]);
+        await this.adb.shell(['run-as', packageId, `mkdir -p '${escapePath(path.posix.dirname(pathInContainer))}'`]);
         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);
@@ -185,8 +177,7 @@ export async function pullFolder(this: AndroidDriver, remotePath: string): Promi
 export async function mobileDeleteFile(this: AndroidDriver, remotePath: string): Promise<boolean> {
   if (remotePath.endsWith('/')) {
     throw new errors.InvalidArgumentError(
-      `It is expected that remote path points to a folder and not to a file. ` +
-        `'${remotePath}' is given instead`,
+      `It is expected that remote path points to a folder and not to a file. '${remotePath}' is given instead`,
     );
   }
   return await deleteFileOrFolder.call(this, this.adb, remotePath);
@@ -201,11 +192,7 @@ export async function mobileDeleteFile(this: AndroidDriver, remotePath: string):
  * If the remote path is valid, but the remote path does not exist
  * this function return `false`.
  */
-async function deleteFileOrFolder(
-  this: AndroidDriver,
-  adb: ADB,
-  remotePath: string,
-): Promise<boolean> {
+async function deleteFileOrFolder(this: AndroidDriver, adb: ADB, remotePath: string): Promise<boolean> {
   const {isDir, isPresent, isFile} = createFSTests(adb);
   let dstPath = remotePath;
   let pkgId: string | undefined;
@@ -246,9 +233,7 @@ async function deleteFileOrFolder(
     await adb.shell(['rm', `-f${expectsFile ? '' : 'r'}`, dstPath]);
   }
   if (await isPresent(dstPath, pkgId)) {
-    throw this.log.errorWithException(
-      `The item at '${dstPath}' still exists after being deleted. Is it writable?`,
-    );
+    throw this.log.errorWithException(`The item at '${dstPath}' still exists after being deleted. Is it writable?`);
   }
   return true;
 }
@@ -285,23 +270,12 @@ async function scanMedia(this: AndroidDriver, remotePath: string): Promise<void>
     if ((await this.adb.getApiLevel()) >= 29) {
       await this.settingsApp.scanMedia(remotePath);
     } else {
-      await this.adb.shell([
-        'am',
-        'broadcast',
-        '-a',
-        ANDROID_MEDIA_RESCAN_INTENT,
-        '-d',
-        `file://${remotePath}`,
-      ]);
+      await this.adb.shell(['am', 'broadcast', '-a', ANDROID_MEDIA_RESCAN_INTENT, '-d', `file://${remotePath}`]);
     }
   } catch (e) {
     const err = e as {stderr?: string; message?: string};
     // FIXME: what has a `stderr` prop?
-    this.log.warn(
-      `Ignoring an unexpected error upon media scanning of '${remotePath}': ${
-        err.stderr ?? err.message
-      }`,
-    );
+    this.log.warn(`Ignoring an unexpected error upon media scanning of '${remotePath}': ${err.stderr ?? err.message}`);
   }
 }
 
@@ -317,11 +291,7 @@ function escapePath(p: string): string {
  * Factory providing filesystem test functions using ADB
  */
 function createFSTests(adb: ADB) {
-  const performRemoteFsCheck = async (
-    p: string,
-    op: 'd' | 'f' | 'e',
-    runAs?: string,
-  ): Promise<boolean> => {
+  const performRemoteFsCheck = async (p: string, op: 'd' | 'f' | 'e', runAs?: string): Promise<boolean> => {
     const passFlag = '__PASS__';
     const checkCmd = `[ -${op} '${escapePath(p)}' ] && echo ${passFlag}`;
     const fullCmd = runAs ? `run-as ${runAs} ${checkCmd}` : checkCmd;
@@ -332,12 +302,9 @@ function createFSTests(adb: ADB) {
     }
   };
 
-  const isFile = async (p: string, runAs?: string): Promise<boolean> =>
-    await performRemoteFsCheck(p, 'f', runAs);
-  const isDir = async (p: string, runAs?: string): Promise<boolean> =>
-    await performRemoteFsCheck(p, 'd', runAs);
-  const isPresent = async (p: string, runAs?: string): Promise<boolean> =>
-    await performRemoteFsCheck(p, 'e', runAs);
+  const isFile = async (p: string, runAs?: string): Promise<boolean> => await performRemoteFsCheck(p, 'f', runAs);
+  const isDir = async (p: string, runAs?: string): Promise<boolean> => await performRemoteFsCheck(p, 'd', runAs);
+  const isPresent = async (p: string, runAs?: string): Promise<boolean> => await performRemoteFsCheck(p, 'e', runAs);
 
   return {isFile, isDir, isPresent};
 }

package/lib/commands/find.ts

@@ -1,7 +1,8 @@
-import {errors, isErrorType} from 'appium/driver.js';
 import {util} from '@appium/support';
-import type {AndroidDriver} from '../driver.js';
 import type {Element} from '@appium/types';
+import {errors, isErrorType} from 'appium/driver.js';
+
+import type {AndroidDriver} from '../driver.js';
 import type {FindElementOpts} from './types.js';
 
 /**
@@ -103,10 +104,7 @@ export async function findElOrEls(
  * @returns A single `Element` if `params.multiple` is `false`, or an array of `Element` objects if `true`.
  * @throws {errors.NotImplementedError} This method must be implemented by the specific context handler.
  */
-export async function doFindElementOrEls(
-  this: AndroidDriver,
-  params: FindElementOpts,
-): Promise<Element | Element[]> {
+export async function doFindElementOrEls(this: AndroidDriver, params: FindElementOpts): Promise<Element | Element[]> {
   void params;
   throw new errors.NotImplementedError('Not implemented');
 }

package/lib/commands/geolocation.ts

@@ -1,11 +1,13 @@
-import {asyncmap} from 'asyncbox';
-import {fs, tempDir} from '@appium/support';
 import path from 'node:path';
+
+import {fs, tempDir} from '@appium/support';
 import type {Location} from '@appium/types';
-import {getThirdPartyPackages} from './app-management.js';
-import type {AndroidDriver} from '../driver.js';
+import {asyncmap} from 'asyncbox';
 import {SETTINGS_HELPER_ID} from 'io.appium.settings';
 
+import type {AndroidDriver} from '../driver.js';
+import {getThirdPartyPackages} from './app-management.js';
+
 // The value close to zero, but not zero, is needed
 // to trick JSON generation and send a float value instead of an integer,
 // This allows strictly-typed clients, like Java, to properly
@@ -87,10 +89,7 @@ export async function mobileSetGeolocation(
  * 20000ms by default.
  * @returns Promise that resolves when the GPS cache refresh is initiated.
  */
-export async function mobileRefreshGpsCache(
-  this: AndroidDriver,
-  timeoutMs?: number,
-): Promise<void> {
+export async function mobileRefreshGpsCache(this: AndroidDriver, timeoutMs?: number): Promise<void> {
   await this.settingsApp.refreshGeoLocationCache(timeoutMs);
 }
 
@@ -135,8 +134,7 @@ export async function toggleLocationServices(this: AndroidDriver): Promise<void>
   this.log.info('Toggling location services');
   const isGpsEnabled = await this.isLocationServicesEnabled();
   this.log.debug(
-    `Current GPS state: ${isGpsEnabled}. ` +
-      `The service is going to be ${isGpsEnabled ? 'disabled' : 'enabled'}`,
+    `Current GPS state: ${isGpsEnabled}. The service is going to be ${isGpsEnabled ? 'disabled' : 'enabled'}`,
   );
   await this.adb.toggleGPSLocationProvider(!isGpsEnabled);
 }
@@ -211,13 +209,7 @@ async function resetMockLocation(this: AndroidDriver): Promise<void> {
     // Only include currently installed packages
     const resultPkgs = pkgIds.filter((pkg) => thirdPartyPkgIds.has(pkg));
     if (resultPkgs.length <= 1) {
-      await this.adb.shell([
-        'appops',
-        'set',
-        resultPkgs[0] ?? SETTINGS_HELPER_ID,
-        'android:mock_location',
-        'deny',
-      ]);
+      await this.adb.shell(['appops', 'set', resultPkgs[0] ?? SETTINGS_HELPER_ID, 'android:mock_location', 'deny']);
       return;
     }
 

package/lib/commands/gestures.ts

@@ -1,5 +1,6 @@
-import {errors} from 'appium/driver.js';
 import type {StringRecord} from '@appium/types';
+import {errors} from 'appium/driver.js';
+
 import type {AndroidDriver} from '../driver.js';
 
 /**

package/lib/commands/image-injection.ts

@@ -1,7 +1,9 @@
-import {errors} from 'appium/driver.js';
+import crypto from 'node:crypto';
 import path from 'node:path';
+
 import {fs, tempDir} from '@appium/support';
-import crypto from 'node:crypto';
+import {errors} from 'appium/driver.js';
+
 import type {AndroidDriver} from '../driver.js';
 
 const EMULATOR_RESOURCES_ROOT = ['emulator', 'resources'];
@@ -30,10 +32,7 @@ const PNG_MAGIC_LENGTH = 4;
  * to load the updated config or `false` if the current config is already up to date
  * or does not need to be updated
  */
-export async function prepareEmulatorForImageInjection(
-  this: AndroidDriver,
-  sdkRoot: string,
-): Promise<boolean> {
+export async function prepareEmulatorForImageInjection(this: AndroidDriver, sdkRoot: string): Promise<boolean> {
   const {injectedImageProperties: props} = this.opts;
   if (!props) {
     return false;
@@ -47,9 +46,7 @@ export async function prepareEmulatorForImageInjection(
   if (await fs.exists(configPath)) {
     const configPayload = await fs.readFile(configPath, 'utf8');
     if (configPayload.includes(strProps)) {
-      this.log.info(
-        `The image injection config at '${configPath}' is already up to date. Doing nothing`,
-      );
+      this.log.info(`The image injection config at '${configPath}' is already up to date. Doing nothing`);
       return false;
     }
     const updatedPayload = `${DEFAULT_CONFIG_PAYLOAD_PREFIX}
@@ -83,10 +80,7 @@ export async function prepareEmulatorForImageInjection(
  * @throws {Error} If called on a non-emulator device.
  * @throws {errors.InvalidArgumentError} If the payload is not a valid base64-encoded PNG.
  */
-export async function mobileInjectEmulatorCameraImage(
-  this: AndroidDriver,
-  payload: string,
-): Promise<void> {
+export async function mobileInjectEmulatorCameraImage(this: AndroidDriver, payload: string): Promise<void> {
   if (!this.isEmulator()) {
     throw new Error('The image injection feature is only available on emulators');
   }
@@ -99,9 +93,7 @@ export async function mobileInjectEmulatorCameraImage(
   const pngBuffer = Buffer.from(payload, 'base64');
   const magic = pngBuffer.toString('hex', 0, PNG_MAGIC_LENGTH);
   if (magic !== PNG_MAGIC) {
-    throw new errors.InvalidArgumentError(
-      'The provided image payload must contain a valid base64-encoded .PNG data',
-    );
+    throw new errors.InvalidArgumentError('The provided image payload must contain a valid base64-encoded .PNG data');
   }
 
   const tmpImagePath = await tempDir.path({
@@ -111,9 +103,7 @@ export async function mobileInjectEmulatorCameraImage(
   });
   await fs.writeFile(tmpImagePath, pngBuffer);
   await this.adb.execEmuConsoleCommand(`virtualscene-image table ${tmpImagePath}`);
-  this.log.info(
-    `The provided image has been successully injected to the ${this.adb.curDeviceId} emulator`,
-  );
+  this.log.info(`The provided image has been successully injected to the ${this.adb.curDeviceId} emulator`);
 }
 
 // #region Internal helpers

package/lib/commands/ime.ts

@@ -1,4 +1,5 @@
 import {errors} from 'appium/driver.js';
+
 import type {AndroidDriver} from '../driver.js';
 import {SET_STYLUS_HANDWRITING_FEATURE} from '../utils.js';
 
@@ -76,11 +77,5 @@ export async function deactivateIMEEngine(this: AndroidDriver): Promise<void> {
  */
 export async function setStylusHandwriting(this: AndroidDriver, enabled: boolean): Promise<void> {
   this.assertFeatureEnabled(SET_STYLUS_HANDWRITING_FEATURE);
-  await this.adb.shell([
-    'settings',
-    'put',
-    'secure',
-    'stylus_handwriting_enabled',
-    enabled ? '1' : '0',
-  ]);
+  await this.adb.shell(['settings', 'put', 'secure', 'stylus_handwriting_enabled', enabled ? '1' : '0']);
 }

package/lib/commands/intent.ts

@@ -1,5 +1,6 @@
-import {errors} from 'appium/driver.js';
 import {util} from '@appium/support';
+import {errors} from 'appium/driver.js';
+
 import type {AndroidDriver} from '../driver.js';
 import type {IntentOpts} from './types.js';
 
@@ -405,8 +406,7 @@ function parseIntentSpec(opts: IntentOpts = {}): string[] {
         resultArgs.push(`--e${type}`, key);
       } else if (value === undefined) {
         throw new errors.InvalidArgumentError(
-          `Intent argument type '${type}' in '${JSON.stringify(item)}' requires a ` +
-            `valid value to be provided`,
+          `Intent argument type '${type}' in '${JSON.stringify(item)}' requires a valid value to be provided`,
         );
       } else {
         resultArgs.push(`--e${type}`, key, value);

package/lib/commands/keyboard.ts

@@ -1,5 +1,6 @@
 import {errors} from 'appium/driver.js';
 import {UNICODE_IME, EMPTY_IME} from 'io.appium.settings';
+
 import type {AndroidDriver} from '../driver.js';
 import type {SendKeysOpts} from './types.js';
 
@@ -57,11 +58,7 @@ export async function doSendKeys(this: AndroidDriver, params: SendKeysOpts): Pro
  * @param metastate Optional meta state flags.
  * @returns Promise that resolves when the key event is sent.
  */
-export async function keyevent(
-  this: AndroidDriver,
-  keycode: string | number,
-  metastate?: number,
-): Promise<void> {
+export async function keyevent(this: AndroidDriver, keycode: string | number, metastate?: number): Promise<void> {
   // TODO deprecate keyevent; currently wd only implements keyevent
   this.log.warn('keyevent will be deprecated use pressKeyCode');
   return await this.pressKeyCode(keycode, metastate);
@@ -75,11 +72,7 @@ export async function keyevent(
  * @returns Promise that resolves when the key code is pressed.
  * @throws {errors.NotImplementedError} This method is not implemented.
  */
-export async function pressKeyCode(
-  this: AndroidDriver,
-  keycode: string | number,
-  metastate?: number,
-): Promise<void> {
+export async function pressKeyCode(this: AndroidDriver, keycode: string | number, metastate?: number): Promise<void> {
   void keycode;
   void metastate;
   throw new errors.NotImplementedError('Not implemented');
@@ -109,10 +102,7 @@ export async function longPressKeyCode(
  * @param action The editor action to perform (e.g., 'done', 'go', 'next').
  * @returns Promise that resolves when the editor action is performed.
  */
-export async function mobilePerformEditorAction(
-  this: AndroidDriver,
-  action: string | number,
-): Promise<void> {
+export async function mobilePerformEditorAction(this: AndroidDriver, action: string | number): Promise<void> {
   await this.settingsApp.performEditorAction(action);
 }
 

package/lib/commands/legacy.ts

@@ -1,4 +1,5 @@
 import {errors} from 'appium/driver.js';
+
 import type {AndroidDriver} from '../driver.js';
 
 const ISSUE_URL = 'https://github.com/appium/appium/issues/15807';

package/lib/commands/lock/exports.ts

@@ -1,4 +1,7 @@
 import {sleep} from 'asyncbox';
+
+import type {AndroidDriver, AndroidDriverCaps} from '../../driver.js';
+import type {UnlockType} from '../types.js';
 import {
   validateUnlockCapabilities,
   FINGERPRINT_UNLOCK,
@@ -15,8 +18,6 @@ import {
   toCredentialType,
   verifyUnlock,
 } from './helpers.js';
-import type {AndroidDriver, AndroidDriverCaps} from '../../driver.js';
-import type {UnlockType} from '../types.js';
 
 /**
  * Locks the device and optionally unlocks it after a specified number of seconds.
@@ -90,10 +91,7 @@ export async function mobileUnlock(
  *
  * @param caps - Optional capabilities to use for unlocking. If not provided, uses session capabilities.
  */
-export async function unlockWithOptions(
-  this: AndroidDriver,
-  caps: AndroidDriverCaps | null = null,
-): Promise<void> {
+export async function unlockWithOptions(this: AndroidDriver, caps: AndroidDriverCaps | null = null): Promise<void> {
   if (!(await this.adb.isScreenLocked())) {
     this.log.info('Screen already unlocked, doing nothing');
     return;
@@ -126,10 +124,7 @@ export async function unlockWithOptions(
       credentialType: toCredentialType(unlockType as UnlockType),
     });
   } else {
-    const unlockMethodMap: Record<
-      string,
-      (this: AndroidDriver, caps: AndroidDriverCaps) => Promise<void>
-    > = {
+    const unlockMethodMap: Record<string, (this: AndroidDriver, caps: AndroidDriverCaps) => Promise<void>> = {
       [PIN_UNLOCK]: pinUnlock,
       [PIN_UNLOCK_KEY_EVENT]: pinUnlockWithKeyEvent,
       [PASSWORD_UNLOCK]: passwordUnlock,