appium-android-driver 13.3.2 → 13.3.4

package/lib/commands/performance.ts

@@ -1,8 +1,8 @@
 import {retryInterval} from 'asyncbox';
-import _ from 'lodash';
 import type {ExecError} from 'teen_process';
 import type {AndroidDriver} from '../driver';
 import type {PerformanceDataType} from './types';
+import {util} from '@appium/support';
 
 export const NETWORK_KEYS = [
   [
@@ -68,7 +68,7 @@ const RETRY_PAUSE_MS = 1000;
  * The possible values are: 'cpuinfo', 'memoryinfo', 'batteryinfo', 'networkinfo'.
  */
 export async function getPerformanceDataTypes(this: AndroidDriver): Promise<PerformanceDataType[]> {
-  return _.keys(SUPPORTED_PERFORMANCE_DATA_TYPES) as PerformanceDataType[];
+  return Object.keys(SUPPORTED_PERFORMANCE_DATA_TYPES) as PerformanceDataType[];
 }
 
 /**
@@ -89,7 +89,7 @@ export async function getPerformanceData(
   dataType: string,
   retries: number = 2,
 ): Promise<any[][]> {
-  switch (_.toLower(dataType)) {
+  switch (dataType?.toLowerCase()) {
     case 'batteryinfo':
       return await getBatteryInfo.call(this, retries);
     case 'cpuinfo':
@@ -187,7 +187,7 @@ export async function getMemoryInfo(
       }
     }
     if (valDict.totalPrivateDirty && valDict.totalPrivateDirty !== 'nodex') {
-      const headers = _.clone(MEMORY_KEYS);
+      const headers = structuredClone(MEMORY_KEYS);
       const values = headers.map((header) => valDict[header]);
       return [headers, values];
     }
@@ -371,11 +371,7 @@ export async function getNetworkTrafficInfo(
       }
     }
 
-    if (
-      !_.isEqual(pendingBytes, '') &&
-      !_.isUndefined(pendingBytes) &&
-      !_.isEqual(pendingBytes, 'nodex')
-    ) {
+    if (pendingBytes !== '' && pendingBytes !== undefined && pendingBytes !== 'nodex') {
       return returnValue;
     } else {
       throw new Error(`Unable to parse network traffic data: '${data}'`);
@@ -427,7 +423,7 @@ export async function getCPUInfo(
     // `output` will be something like
     //    +0% 2209/io.appium.android.apis: 0.1% user + 0.2% kernel / faults: 70 minor
     const usagesPattern = new RegExp(
-      `^.+\\/${_.escapeRegExp(packageName)}:\\D+([\\d.]+)%\\s+user\\s+\\+\\s+([\\d.]+)%\\s+kernel`,
+      `^.+\\/${util.escapeRegExp(packageName)}:\\D+([\\d.]+)%\\s+user\\s+\\+\\s+([\\d.]+)%\\s+kernel`,
       'm',
     );
     const match = usagesPattern.exec(output);
@@ -462,7 +458,7 @@ export async function getBatteryInfo(this: AndroidDriver, retries: number = 2):
     const power = parseInt((data.split(':')[1] || '').trim(), 10);
 
     if (!Number.isNaN(power)) {
-      return [_.clone(BATTERY_KEYS), [power.toString()]];
+      return [structuredClone(BATTERY_KEYS), [power.toString()]];
     } else {
       throw new Error(`Unable to parse battery data: '${data}'`);
     }

package/lib/commands/permissions.ts

@@ -1,7 +1,7 @@
 import {errors} from 'appium/driver';
-import _ from 'lodash';
 import {ADB_SHELL_FEATURE} from '../utils';
 import type {AndroidDriver} from '../driver';
+import {util} from '@appium/support';
 
 const ALL_PERMISSIONS_MAGIC = 'all';
 const PM_ACTION = Object.freeze({
@@ -67,31 +67,32 @@ export async function mobileChangePermissions(
   if (!appPackage) {
     throw new errors.InvalidArgumentError(`A valid appPackage must be provided`);
   }
-  action ??= _.toLower(target) === PERMISSION_TARGET.APPOPS ? APPOPS_ACTION.ALLOW : PM_ACTION.GRANT;
-  if (_.isNil(permissions)) {
+  action ??=
+    target?.toLowerCase() === PERMISSION_TARGET.APPOPS ? APPOPS_ACTION.ALLOW : PM_ACTION.GRANT;
+  if (permissions == null) {
     throw new errors.InvalidArgumentError(`'permissions' argument is required`);
   }
-  if (_.isEmpty(permissions)) {
+  if (util.isEmpty(permissions)) {
     throw new errors.InvalidArgumentError(`'permissions' argument must not be empty`);
   }
 
-  switch (_.toLower(target)) {
+  switch (target?.toLowerCase()) {
     case PERMISSION_TARGET.PM:
       return await changePermissionsViaPm.bind(this)(
         permissions,
         appPackage,
-        _.toLower(action) as PMAction,
+        action?.toLowerCase() as PMAction,
       );
     case PERMISSION_TARGET.APPOPS:
       this.assertFeatureEnabled(ADB_SHELL_FEATURE);
       return await changePermissionsViaAppops.bind(this)(
         permissions,
         appPackage,
-        _.toLower(action) as AppOpsAction,
+        action?.toLowerCase() as AppOpsAction,
       );
     default:
       throw new errors.InvalidArgumentError(
-        `'target' argument must be one of: ${_.values(PERMISSION_TARGET)}`,
+        `'target' argument must be one of: ${Object.values(PERMISSION_TARGET)}`,
       );
   }
 }
@@ -111,7 +112,7 @@ export async function mobileGetPermissions(
 ): Promise<string[]> {
   appPackage ??= this.opts.appPackage;
   let actionFunc: (pkg: string) => Promise<string[]>;
-  switch (_.toLower(type)) {
+  switch (type?.toLowerCase()) {
     case PERMISSIONS_TYPE.REQUESTED:
       actionFunc = (pkg) => this.adb.getReqPermissions(pkg);
       break;
@@ -124,7 +125,7 @@ export async function mobileGetPermissions(
     default:
       throw new errors.InvalidArgumentError(
         `Unknown permissions type '${type}'. ` +
-          `Only ${JSON.stringify(_.values(PERMISSIONS_TYPE))} types are supported`,
+          `Only ${JSON.stringify(Object.values(PERMISSIONS_TYPE))} types are supported`,
       );
   }
   return await actionFunc(appPackage as string);
@@ -135,24 +136,26 @@ async function changePermissionsViaPm(
   appPackage: string,
   action: PMAction,
 ): Promise<void> {
-  if (!_.values(PM_ACTION).includes(action)) {
+  if (!Object.values(PM_ACTION).includes(action)) {
     throw new errors.InvalidArgumentError(
       `Unknown action '${action}'. ` +
-        `Only ${JSON.stringify(_.values(PM_ACTION))} actions are supported`,
+        `Only ${JSON.stringify(Object.values(PM_ACTION))} actions are supported`,
     );
   }
 
-  let affectedPermissions = _.isArray(permissions) ? permissions : [permissions];
-  if (_.isString(permissions) && _.toLower(permissions) === ALL_PERMISSIONS_MAGIC) {
+  let affectedPermissions = Array.isArray(permissions) ? permissions : [permissions];
+  if (typeof permissions === 'string' && permissions.toLowerCase() === ALL_PERMISSIONS_MAGIC) {
     const dumpsys = await this.adb.shell(['dumpsys', 'package', appPackage]);
     const grantedPermissions = await this.adb.getGrantedPermissions(appPackage, dumpsys);
     if (action === PM_ACTION.GRANT) {
       const reqPermissons = await this.adb.getReqPermissions(appPackage, dumpsys);
-      affectedPermissions = _.difference(reqPermissons, grantedPermissions);
+      affectedPermissions = reqPermissons.filter(
+        (permission) => !grantedPermissions.includes(permission),
+      );
     } else {
       affectedPermissions = grantedPermissions;
     }
-    if (_.isEmpty(affectedPermissions)) {
+    if (util.isEmpty(affectedPermissions)) {
       this.log.info(`'${appPackage}' contains no permissions to ${action}`);
       return;
     }
@@ -172,13 +175,13 @@ async function changePermissionsViaAppops(
   appPackage: string,
   action: AppOpsAction,
 ): Promise<void> {
-  if (!_.values(APPOPS_ACTION).includes(action)) {
+  if (!Object.values(APPOPS_ACTION).includes(action)) {
     throw new errors.InvalidArgumentError(
       `Unknown action '${action}'. ` +
-        `Only ${JSON.stringify(_.values(APPOPS_ACTION))} actions are supported`,
+        `Only ${JSON.stringify(Object.values(APPOPS_ACTION))} actions are supported`,
     );
   }
-  if (_.isString(permissions) && _.toLower(permissions) === ALL_PERMISSIONS_MAGIC) {
+  if (typeof permissions === 'string' && permissions.toLowerCase() === ALL_PERMISSIONS_MAGIC) {
     throw new errors.InvalidArgumentError(
       `'${ALL_PERMISSIONS_MAGIC}' permission is only supported for ` +
         `'${PERMISSION_TARGET.PM}' target. ` +
@@ -186,7 +189,7 @@ async function changePermissionsViaAppops(
     );
   }
 
-  const promises = (_.isArray(permissions) ? permissions : [permissions]).map((permission) =>
+  const promises = (Array.isArray(permissions) ? permissions : [permissions]).map((permission) =>
     this.adb.shell(['appops', 'set', appPackage, permission, action]),
   );
   await Promise.all(promises);

package/lib/commands/recordscreen.ts

@@ -1,7 +1,6 @@
 import {fs, net, system, tempDir, timing, util} from '@appium/support';
 import type {NetOptions, HttpUploadOptions} from '@appium/support';
 import {waitForCondition} from 'asyncbox';
-import _ from 'lodash';
 import path from 'node:path';
 import {exec} from 'teen_process';
 import type {AndroidDriver} from '../driver';
@@ -63,7 +62,7 @@ export async function startRecordingScreen(
     );
   }
 
-  if (!_.isEmpty(this._screenRecordingProperties)) {
+  if (this._screenRecordingProperties) {
     // XXX: this doesn't need to be done in serial, does it?
     const props = this._screenRecordingProperties;
     for (const record of props.records || []) {
@@ -117,7 +116,7 @@ export async function stopRecordingScreen(
   await verifyScreenRecordIsSupported(this.adb, this.isEmulator());
 
   const props = this._screenRecordingProperties;
-  if (!_.isEmpty(props)) {
+  if (props) {
     props.stopped = true;
   }
 
@@ -125,12 +124,12 @@ export async function stopRecordingScreen(
     await terminateBackgroundScreenRecording(this.adb, false);
   } catch (err) {
     this.log.warn((err as Error).message);
-    if (!_.isEmpty(props)) {
+    if (props) {
       this.log.warn('The resulting video might be corrupted');
     }
   }
 
-  if (_.isEmpty(props)) {
+  if (!props) {
     this.log.info(
       `Screen recording has not been previously started by Appium. There is nothing to stop`,
     );
@@ -148,7 +147,7 @@ export async function stopRecordingScreen(
     props.recordingProcess = null;
   }
 
-  if (_.isEmpty(props.records)) {
+  if (util.isEmpty(props.records)) {
     throw this.log.errorWithException(
       `No screen recordings have been stored on the device so far. ` +
         `Are you sure the ${SCREENRECORD_BINARY} utility works as expected?`,
@@ -164,7 +163,7 @@ export async function stopRecordingScreen(
       await this.adb.pull(pathOnDevice, relativePath, {timeout: ADB_PULL_TIMEOUT});
       await this.adb.rimraf(pathOnDevice);
     }
-    let resultFilePath = _.last(localRecords) as string;
+    let resultFilePath = localRecords.at(-1) as string;
     if (localRecords.length > 1) {
       this.log.info(`Got ${localRecords.length} screen recordings. Trying to merge them`);
       try {
@@ -176,7 +175,7 @@ export async function stopRecordingScreen(
         );
       }
     }
-    if (_.isEmpty(options.remotePath)) {
+    if (util.isEmpty(options.remotePath)) {
       const {size} = await fs.stat(resultFilePath);
       this.log.debug(
         `The size of the resulting screen recording is ${util.toReadableSizeString(size)}`,
@@ -196,7 +195,7 @@ async function uploadRecordedMedia(
   remotePath?: string,
   uploadOptions: StopScreenRecordingOpts = {},
 ): Promise<string> {
-  if (_.isEmpty(remotePath)) {
+  if (util.isEmpty(remotePath)) {
     return (await util.toInMemoryBase64(localFile)).toString();
   }
 
@@ -322,14 +321,14 @@ async function mergeScreenRecords(this: AndroidDriver, mediaFiles: string[]): Pr
 
 async function terminateBackgroundScreenRecording(adb: ADB, force = true): Promise<boolean> {
   const screenrecordPids = await adb.getProcessIdsByName(SCREENRECORD_BINARY);
-  if (_.isEmpty(screenrecordPids)) {
+  if (util.isEmpty(screenrecordPids)) {
     return false;
   }
 
   try {
     await adb.shell(['kill', force ? '-15' : '-2', ...screenrecordPids.map(String)]);
     await waitForCondition(
-      async () => _.isEmpty(await adb.getProcessIdsByName(SCREENRECORD_BINARY)),
+      async () => util.isEmpty(await adb.getProcessIdsByName(SCREENRECORD_BINARY)),
       {
         waitMs: PROCESS_SHUTDOWN_TIMEOUT,
         intervalMs: 500,

package/lib/commands/resources.ts

@@ -1,5 +1,4 @@
-import _ from 'lodash';
-import {fs, tempDir} from '@appium/support';
+import {fs, tempDir, util} from '@appium/support';
 import type {StringRecord} from '@appium/types';
 import type {AndroidDriver, AndroidDriverOpts} from '../driver';
 import type {Locale} from './types';
@@ -24,8 +23,8 @@ export async function getStrings(
   // and values of type string
   const preprocessStringsMap = (mapping: StringRecord): StringRecord => {
     const result: StringRecord = {};
-    for (const [key, value] of _.toPairs(mapping)) {
-      result[key] = _.isString(value) ? value : JSON.stringify(value);
+    for (const [key, value] of Object.entries(mapping)) {
+      result[key] = typeof value === 'string' ? value : JSON.stringify(value);
     }
     return result;
   };
@@ -63,7 +62,7 @@ export async function ensureDeviceLocale(
     } catch (e1) {
       this.log.debug((e1 as Error).stack);
     }
-    if (!_.isEmpty(suggestions)) {
+    if (suggestions.length > 0) {
       errMsg += ` You may want to apply one of the following locales instead: ${suggestions}`;
     }
     throw new Error(errMsg, {cause: e});
@@ -114,10 +113,10 @@ async function fetchLocaleSuggestions(
   const supportedLocales = await this.settingsApp.listSupportedLocales();
   const suggestedLocales = supportedLocales.filter(
     (locale) =>
-      _.toLower(language) === _.toLower(locale.language) ||
-      _.toLower(country) === _.toLower(locale.country),
+      language?.toLowerCase() === locale.language?.toLowerCase() ||
+      country?.toLowerCase() === locale.country?.toLowerCase(),
   );
-  return _.isEmpty(suggestedLocales) ? supportedLocales : suggestedLocales;
+  return util.isEmpty(suggestedLocales) ? supportedLocales : suggestedLocales;
 }
 
 function toLocaleAbbr({language, country, script}: Locale): string {

package/lib/commands/shell.ts

@@ -1,6 +1,5 @@
 import {util} from '@appium/support';
 import {errors} from 'appium/driver';
-import _ from 'lodash';
 import {exec} from 'teen_process';
 import type {ExecError} from 'teen_process';
 import {ADB_SHELL_FEATURE} from '../utils';
@@ -36,11 +35,16 @@ export async function mobileShell<T extends boolean>(
 ): Promise<T extends true ? {stdout: string; stderr: string} : string> {
   this.assertFeatureEnabled(ADB_SHELL_FEATURE);
 
-  if (!_.isString(command)) {
+  if (typeof command !== 'string') {
     throw new errors.InvalidArgumentError(`The 'command' argument is mandatory`);
   }
 
-  const adbArgs = [...this.adb.executable.defaultArgs, 'shell', command, ..._.castArray(args)];
+  const adbArgs = [
+    ...this.adb.executable.defaultArgs,
+    'shell',
+    command,
+    ...(Array.isArray(args) ? args : [args]),
+  ];
   this.log.debug(`Running '${this.adb.executable.path} ${util.quote(adbArgs)}'`);
   try {
     const {stdout, stderr} = await exec(this.adb.executable.path, adbArgs, {timeout});

package/lib/commands/streamscreen.ts

@@ -1,6 +1,5 @@
 import {fs, logger, system, util} from '@appium/support';
 import {waitForCondition} from 'asyncbox';
-import _ from 'lodash';
 import {spawn} from 'node:child_process';
 import http from 'node:http';
 import net from 'node:net';
@@ -89,10 +88,9 @@ export async function mobileStartScreenStreaming(
 ): Promise<void> {
   this.assertFeatureEnabled(ADB_SCREEN_STREAMING_FEATURE);
 
-  if (_.isUndefined(this._screenStreamingProps)) {
+  if (this._screenStreamingProps === undefined) {
     await verifyStreamingRequirements(this.adb);
-  }
-  if (!_.isEmpty(this._screenStreamingProps)) {
+  } else {
     this.log.info(
       `The screen streaming session is already running. ` +
         `Stop it first in order to start a new one.`,
@@ -246,8 +244,8 @@ export async function mobileStartScreenStreaming(
  * If no streaming session is active, this method returns without error.
  */
 export async function mobileStopScreenStreaming(this: AndroidDriver): Promise<void> {
-  if (_.isEmpty(this._screenStreamingProps)) {
-    if (!_.isUndefined(this._screenStreamingProps)) {
+  if (!this._screenStreamingProps) {
+    if (this._screenStreamingProps !== undefined) {
       this.log.debug(`Screen streaming is not running. There is nothing to stop`);
     }
     return;
@@ -287,7 +285,7 @@ export async function mobileStopScreenStreaming(this: AndroidDriver): Promise<vo
 function createStreamingLogger(streamName: string, udid: string): AppiumLogger {
   return logger.getLogger(
     `${streamName}@` +
-      _.truncate(udid, {
+      util.truncateString(udid, {
         length: 8,
         omission: '',
       }),
@@ -295,7 +293,7 @@ function createStreamingLogger(streamName: string, udid: string): AppiumLogger {
 }
 
 async function verifyStreamingRequirements(adb: ADB): Promise<void> {
-  if (!_.trim(await adb.shell(['which', SCREENRECORD_BINARY]))) {
+  if (!(await adb.shell(['which', SCREENRECORD_BINARY])).trim()) {
     throw new Error(
       `The required '${SCREENRECORD_BINARY}' binary is not available on the device under test`,
     );
@@ -319,11 +317,11 @@ async function verifyStreamingRequirements(adb: ADB): Promise<void> {
   await Promise.all(gstreamerCheckPromises);
 
   const moduleCheckPromises: Promise<void>[] = [];
-  for (const [name, modName] of _.toPairs(REQUIRED_GST_PLUGINS)) {
+  for (const [name, modName] of Object.entries(REQUIRED_GST_PLUGINS)) {
     moduleCheckPromises.push(
       (async () => {
         const {stdout} = await exec(GST_INSPECT_BINARY, [name]);
-        if (!_.includes(stdout, modName)) {
+        if (!stdout?.includes(modName)) {
           throw new Error(
             `The required GStreamer plugin '${name}' from '${modName}' module is not installed. ` +
               `See ${GST_TUTORIAL_URL} for more details on how to install it.`,
@@ -366,9 +364,9 @@ async function initDeviceStreamingProc(
   opts: {width?: string | number; height?: string | number; bitRate?: string | number} = {},
 ): Promise<ReturnType<typeof spawn>> {
   const {width, height, bitRate} = opts;
-  const adjustedWidth = _.isUndefined(width) ? deviceInfo.width : parseInt(String(width), 10);
-  const adjustedHeight = _.isUndefined(height) ? deviceInfo.height : parseInt(String(height), 10);
-  const adjustedBitrate = _.isUndefined(bitRate) ? DEFAULT_BITRATE : parseInt(String(bitRate), 10);
+  const adjustedWidth = width === undefined ? deviceInfo.width : parseInt(String(width), 10);
+  const adjustedHeight = height === undefined ? deviceInfo.height : parseInt(String(height), 10);
+  const adjustedBitrate = bitRate === undefined ? DEFAULT_BITRATE : parseInt(String(bitRate), 10);
   let screenRecordCmd =
     SCREENRECORD_BINARY +
     ` --output-format=h264` +
@@ -396,7 +394,7 @@ async function initDeviceStreamingProc(
   const deviceStreamingLogger = createStreamingLogger(SCREENRECORD_BINARY, deviceInfo.udid);
   const errorsListener = (chunk: Buffer | string) => {
     const stderr = chunk.toString();
-    if (_.trim(stderr)) {
+    if (stderr?.trim()) {
       deviceStreamingLogger.debug(stderr);
     }
   };
@@ -404,7 +402,7 @@ async function initDeviceStreamingProc(
 
   const startupListener = (chunk: Buffer | string) => {
     if (!isStarted) {
-      isStarted = !_.isEmpty(chunk);
+      isStarted = !util.isEmpty(chunk);
     }
   };
   deviceStreaming.stdout.on('data', startupListener);
@@ -477,7 +475,7 @@ async function initGstreamerPipeline(
   });
   const gstreamerLogger = createStreamingLogger('gst', deviceInfo.udid);
   const gstOutputListener = (stdout: string, stderr: string) => {
-    if (_.trim(stderr || stdout)) {
+    if ((stderr || stdout)?.trim()) {
       gstreamerLogger.debug(stderr || stdout);
     }
   };

package/lib/commands/system-bars.ts

@@ -1,8 +1,8 @@
 import {errors} from 'appium/driver';
-import _ from 'lodash';
 import type {StringRecord} from '@appium/types';
 import type {AndroidDriver} from '../driver';
 import type {StatusBarCommand, WindowProperties} from './types';
+import {util} from '@appium/support';
 
 const WINDOW_TITLE_PATTERN = /^\s+Window\s#\d+\sWindow\{[0-9a-f]+\s\w+\s([\w-]+)\}:$/;
 const FRAME_PATTERN = /\bm?[Ff]rame=\[([0-9.-]+),([0-9.-]+)\]\[([0-9.-]+),([0-9.-]+)\]/;
@@ -64,15 +64,15 @@ export async function mobilePerformStatusBarCommand(
   component?: string,
 ): Promise<string> {
   const toStatusBarCommandCallable =
-    (cmd: string, argsCallable?: () => string[] | string) => async (): Promise<string> =>
-      await this.adb.shell([
-        'cmd',
-        'statusbar',
-        cmd,
-        ...(argsCallable ? _.castArray(argsCallable()) : []),
-      ]);
+    (cmd: string, argsCallable?: () => string[] | string) => async (): Promise<string> => {
+      let argsCallableArray = argsCallable ? argsCallable() : [];
+      if (!Array.isArray(argsCallableArray)) {
+        argsCallableArray = [argsCallableArray];
+      }
+      return await this.adb.shell(['cmd', 'statusbar', cmd, ...argsCallableArray]);
+    };
   const tileCommandArgsCallable = () => component as string;
-  const statusBarCommands = _.fromPairs(
+  const statusBarCommands = Object.fromEntries(
     (
       [
         ['expandNotifications', ['expand-notifications']],
@@ -90,7 +90,7 @@ export async function mobilePerformStatusBarCommand(
   if (!action) {
     throw new errors.InvalidArgumentError(
       `The '${command}' status bar command is unknown. Only the following commands ` +
-        `are supported: ${_.keys(statusBarCommands)}`,
+        `are supported: ${Object.keys(statusBarCommands)}`,
     );
   }
   return await action();
@@ -110,7 +110,7 @@ export function parseWindowProperties(
   name: string,
   props: string[],
 ): WindowProperties {
-  const result = _.cloneDeep(DEFAULT_WINDOW_PROPERTIES);
+  const result = structuredClone(DEFAULT_WINDOW_PROPERTIES);
   const propLines = props.join('\n');
   const frameMatch = FRAME_PATTERN.exec(propLines);
   if (!frameMatch) {
@@ -142,29 +142,29 @@ export function parseWindowProperties(
 export function parseWindows(this: AndroidDriver, lines: string): SystemBarsResult {
   const windows: StringRecord<string[]> = {};
   let currentWindowName: string | null = null;
-  for (const line of lines.split('\n').map(_.trimEnd)) {
-    const match = WINDOW_TITLE_PATTERN.exec(line);
+  for (const line of lines.split('\n').map((line) => String(line)?.trimEnd())) {
+    const match = WINDOW_TITLE_PATTERN.exec(line as any);
     if (match) {
       currentWindowName = match[1];
       windows[currentWindowName] = [];
       continue;
     }
-    if (_.trim(line).length === 0) {
+    if (String(line)?.trim()?.length === 0) {
       currentWindowName = null;
       continue;
     }
 
-    if (currentWindowName && _.isArray(windows[currentWindowName])) {
+    if (currentWindowName && Array.isArray(windows[currentWindowName])) {
       windows[currentWindowName].push(line);
     }
   }
-  if (_.isEmpty(windows)) {
+  if (util.isEmpty(windows)) {
     this.log.debug(lines);
     throw new Error('Cannot parse any window information from the dumpsys output');
   }
 
   const result: SystemBarsResult = {};
-  for (const [name, props] of _.toPairs(windows)) {
+  for (const [name, props] of Object.entries(windows)) {
     if (
       name.startsWith(STATUS_BAR_WINDOW_NAME_PREFIX) ||
       props.some((line: string) => STATUS_BAR_TYPE_PATTERN.test(line))
@@ -182,14 +182,14 @@ export function parseWindows(this: AndroidDriver, lines: string): SystemBarsResu
       ['statusBar', STATUS_BAR_WINDOW_NAME_PREFIX],
       ['navigationBar', NAVIGATION_BAR_WINDOW_NAME_PREFIX],
     ] as const
-  ).filter(([name]) => _.isNil(result[name as keyof SystemBarsResult]));
+  ).filter(([name]) => result[name as keyof SystemBarsResult] == null);
   for (const [window, namePrefix] of unmatchedWindows) {
     this.log.info(
       `No windows have been found whose title matches to ` +
         `'${namePrefix}'. Assuming it is invisible. ` +
-        `Only the following windows are available: ${_.keys(windows)}`,
+        `Only the following windows are available: ${Object.keys(windows)}`,
     );
-    result[window as keyof SystemBarsResult] = _.cloneDeep(DEFAULT_WINDOW_PROPERTIES);
+    result[window as keyof SystemBarsResult] = structuredClone(DEFAULT_WINDOW_PROPERTIES);
   }
   return result;
 }

package/lib/driver.ts

@@ -7,7 +7,6 @@ import type {
   StringRecord,
   W3CDriverCaps,
 } from '@appium/types';
-import _ from 'lodash';
 import type {ADB, LogcatListener} from 'appium-adb';
 import type {default as AppiumChromedriver} from 'appium-chromedriver';
 import {BaseDriver} from 'appium/driver';
@@ -462,7 +461,7 @@ class AndroidDriver
       'accessibility id',
       '-android uiautomator',
     ];
-    this.desiredCapConstraints = _.cloneDeep(ANDROID_DRIVER_CONSTRAINTS);
+    this.desiredCapConstraints = structuredClone(ANDROID_DRIVER_CONSTRAINTS);
     this.sessionChromedrivers = {};
     this.jwpProxyActive = false;
 
@@ -483,8 +482,7 @@ class AndroidDriver
   }
 
   get isChromeSession(): boolean {
-    return _.includes(
-      Object.keys(CHROME_BROWSER_PACKAGE_ACTIVITY),
+    return Object.keys(CHROME_BROWSER_PACKAGE_ACTIVITY).includes(
       (this.opts.browserName || '').toLowerCase(),
     );
   }

package/lib/utils.ts

@@ -1,7 +1,7 @@
-import _ from 'lodash';
 import {errors} from 'appium/driver';
 import type {LogEntry} from 'appium-adb';
 import type {AndroidDriver} from './driver';
+import {util} from '@appium/support';
 
 export type {LogEntry};
 
@@ -29,8 +29,8 @@ export function requireArgs(
   argNames: string | string[],
   opts: Record<string, any>,
 ): Record<string, any> {
-  for (const argName of _.isArray(argNames) ? argNames : [argNames]) {
-    if (!_.has(opts, argName)) {
+  for (const argName of Array.isArray(argNames) ? argNames : [argNames]) {
+    if (util.isPlainObject(opts) && !Object.hasOwn(opts, argName)) {
       throw new errors.InvalidArgumentError(`'${argName}' argument must be provided`);
     }
   }
@@ -48,9 +48,9 @@ export function parseArray(cap: string | string[]): string[] {
     parsedCaps = JSON.parse(cap as string);
   } catch {}
 
-  if (_.isArray(parsedCaps)) {
+  if (Array.isArray(parsedCaps)) {
     return parsedCaps;
-  } else if (_.isString(cap)) {
+  } else if (typeof cap === 'string') {
     return [cap];
   }
 
@@ -62,12 +62,12 @@ export function parseArray(cap: string | string[]): string[] {
  * @returns
  */
 export async function removeAllSessionWebSocketHandlers(this: AndroidDriver): Promise<void> {
-  if (!this.sessionId || !_.isFunction(this.server?.getWebSocketHandlers)) {
+  if (!this.sessionId || typeof this.server?.getWebSocketHandlers !== 'function') {
     return;
   }
 
   const activeHandlers = await this.server.getWebSocketHandlers(this.sessionId);
-  for (const pathname of _.keys(activeHandlers)) {
+  for (const pathname of Object.keys(activeHandlers)) {
     await this.server.removeWebSocketHandler(pathname);
   }
 }
@@ -78,8 +78,8 @@ export async function removeAllSessionWebSocketHandlers(this: AndroidDriver): Pr
  * @returns
  */
 export function nativeLogEntryToSeleniumEntry(x: LogEntryWithPrefix): LogEntry {
-  const msg = _.isEmpty(x.prefix) ? x.message : `[${x.prefix}] ${x.message}`;
-  return toLogRecord(x.timestamp ?? Date.now(), _.replace(msg, COLOR_CODE_PATTERN, ''));
+  const msg = util.isEmpty(x.prefix) ? x.message : `[${x.prefix}] ${x.message}`;
+  return toLogRecord(x.timestamp ?? Date.now(), msg.replace(COLOR_CODE_PATTERN, ''));
 }
 
 /**