appium-android-driver 13.3.1 → 13.3.3

package/lib/commands/lock/exports.ts

@@ -15,7 +15,6 @@ import {
   toCredentialType,
   verifyUnlock,
 } from './helpers';
-import _ from 'lodash';
 import type {AndroidDriver, AndroidDriverCaps} from '../../driver';
 import type {UnlockType} from '../types';
 
@@ -119,7 +118,7 @@ export async function unlockWithOptions(
   if (
     unlockKey &&
     unlockType !== FINGERPRINT_UNLOCK &&
-    (_.isNil(unlockStrategy) || _.toLower(unlockStrategy) === 'locksettings') &&
+    (unlockStrategy == null || String(unlockStrategy)?.toLowerCase() === 'locksettings') &&
     (await this.adb.isLockManagementSupported())
   ) {
     await fastUnlock.bind(this)({

package/lib/commands/lock/helpers.ts

@@ -1,6 +1,5 @@
 import {util} from '@appium/support';
 import {sleep, waitForCondition} from 'asyncbox';
-import _ from 'lodash';
 import type {ADB} from 'appium-adb';
 import type {Position, StringRecord} from '@appium/types';
 import type {AndroidDriver, AndroidDriverCaps} from '../../driver';
@@ -58,16 +57,16 @@ export function validateUnlockCapabilities<T extends AndroidDriverCaps>(caps: T)
   }
 
   if ([PIN_UNLOCK, PIN_UNLOCK_KEY_EVENT, FINGERPRINT_UNLOCK].includes(unlockType)) {
-    if (!/^[0-9]+$/.test(_.trim(unlockKey))) {
+    if (!/^[0-9]+$/.test(String(unlockKey)?.trim())) {
       throw new Error(`Unlock key value '${unlockKey}' must only consist of digits`);
     }
   } else if (unlockType === PATTERN_UNLOCK) {
-    if (!/^[1-9]{2,9}$/.test(_.trim(unlockKey))) {
+    if (!/^[1-9]{2,9}$/.test(String(unlockKey)?.trim())) {
       throw new Error(
         `Unlock key value '${unlockKey}' must only include from two to nine digits in range 1..9`,
       );
     }
-    if (/([1-9]).*?\1/.test(_.trim(unlockKey))) {
+    if (/([1-9]).*?\1/.test(String(unlockKey)?.trim())) {
       throw new Error(
         `Unlock key value '${unlockKey}' must define a valid pattern where repeats are not allowed`,
       );
@@ -161,7 +160,7 @@ export async function pinUnlock(
   await this.adb.dismissKeyguard();
   const keys = stringKeyToArr(String(capabilities.unlockKey));
   const els = await this.findElOrEls('id', 'com.android.systemui:id/digit_text', true);
-  if (_.isEmpty(els)) {
+  if (util.isEmpty(els)) {
     // fallback to pin with key event
     return await pinUnlockWithKeyEvent.bind(this)(capabilities);
   }
@@ -267,7 +266,7 @@ export function getPatternActions(
 ): StringRecord[] {
   // https://www.w3.org/TR/webdriver2/#actions
   const pointerActions: StringRecord[] = [];
-  const intKeys = keys.map((key) => (_.isString(key) ? _.parseInt(key) : key));
+  const intKeys = keys.map((key) => (typeof key === 'string' ? parseInt(key, 10) : key));
   let lastPos: Position | undefined;
   for (const key of intKeys) {
     const keyPos = getPatternKeyPosition(key, initPos, piece);

package/lib/commands/log.ts

@@ -1,5 +1,4 @@
 import {DEFAULT_WS_PATHNAME_PREFIX, BaseDriver} from 'appium/driver';
-import _ from 'lodash';
 import os from 'node:os';
 import WebSocket from 'ws';
 import type {AppiumServer, WSServer} from '@appium/types';
@@ -16,6 +15,7 @@ import {NATIVE_WIN} from './context/helpers';
 import {BIDI_EVENT_NAME} from './bidi/constants';
 import {makeLogEntryAddedEvent} from './bidi/models';
 import type {AndroidDriver} from '../driver';
+import {util} from '@appium/support';
 
 export const supportedLogTypes = {
   logcat: {
@@ -52,7 +52,7 @@ export const supportedLogTypes = {
 export async function mobileStartLogsBroadcast(this: AndroidDriver): Promise<void> {
   const server = this.server as AppiumServer;
   const pathname = WEBSOCKET_ENDPOINT(this.sessionId as string);
-  if (!_.isEmpty(await server.getWebSocketHandlers(pathname))) {
+  if (!util.isEmpty(await server.getWebSocketHandlers(pathname))) {
     this.log.debug(`The logcat broadcasting web socket server is already listening at ${pathname}`);
     return;
   }
@@ -67,7 +67,7 @@ export async function mobileStartLogsBroadcast(this: AndroidDriver): Promise<voi
   });
   wss.on('connection', (ws, req) => {
     if (req) {
-      const remoteIp = _.isEmpty(req.headers['x-forwarded-for'])
+      const remoteIp = util.isEmpty(req.headers['x-forwarded-for'])
         ? req.socket.remoteAddress
         : req.headers['x-forwarded-for'];
       this.log.debug(`Established a new logcat listener web socket connection from ${remoteIp}`);
@@ -75,7 +75,7 @@ export async function mobileStartLogsBroadcast(this: AndroidDriver): Promise<voi
       this.log.debug('Established a new logcat listener web socket connection');
     }
 
-    if (_.isEmpty(this._logcatWebsocketListener)) {
+    if (!this._logcatWebsocketListener) {
       this._logcatWebsocketListener = (logRecord: LogEntry) => {
         if (ws?.readyState === WebSocket.OPEN) {
           ws.send(logRecord.message);
@@ -85,7 +85,7 @@ export async function mobileStartLogsBroadcast(this: AndroidDriver): Promise<voi
     this.adb.setLogcatListener(this._logcatWebsocketListener);
 
     ws.on('close', (code, reason) => {
-      if (!_.isEmpty(this._logcatWebsocketListener)) {
+      if (this._logcatWebsocketListener) {
         try {
           this.adb.removeLogcatListener(this._logcatWebsocketListener);
         } catch {}
@@ -93,10 +93,10 @@ export async function mobileStartLogsBroadcast(this: AndroidDriver): Promise<voi
       }
 
       let closeMsg = 'Logcat listener web socket is closed.';
-      if (!_.isEmpty(code)) {
+      if (!util.isEmpty(code)) {
         closeMsg += ` Code: ${code}.`;
       }
-      if (!_.isEmpty(reason)) {
+      if (!util.isEmpty(reason)) {
         closeMsg += ` Reason: ${reason.toString()}.`;
       }
       this.log.debug(closeMsg);
@@ -114,7 +114,7 @@ export async function mobileStartLogsBroadcast(this: AndroidDriver): Promise<voi
 export async function mobileStopLogsBroadcast(this: AndroidDriver): Promise<void> {
   const pathname = WEBSOCKET_ENDPOINT(this.sessionId as string);
   const server = this.server as AppiumServer;
-  if (_.isEmpty(await server.getWebSocketHandlers(pathname))) {
+  if (util.isEmpty(await server.getWebSocketHandlers(pathname))) {
     return;
   }
 
@@ -174,7 +174,7 @@ export function assignBiDiLogListener<EE extends EventEmitter>(
  * @returns Promise that resolves to the logs for the specified type.
  */
 export async function getLog(this: AndroidDriver, logType: string): Promise<any> {
-  if (this.isWebContext() && !_.keys(this.supportedLogTypes).includes(logType)) {
+  if (this.isWebContext() && !Object.keys(this.supportedLogTypes).includes(logType)) {
     return await (this.chromedriver as Chromedriver).jwproxy.command('/log', 'POST', {
       type: logType,
     });

package/lib/commands/media-projection.ts

@@ -1,7 +1,6 @@
 import {fs, net, util} from '@appium/support';
 import type {NetOptions, HttpUploadOptions} from '@appium/support';
-import _ from 'lodash';
-import moment from 'moment';
+import dayjs from 'dayjs';
 import path from 'node:path';
 import type {HTTPMethod, StringRecord} from '@appium/types';
 import type {AndroidDriver} from '../driver';
@@ -51,7 +50,7 @@ export async function mobileStartMediaProjectionRecording(
   await verifyMediaProjectionRecordingIsSupported(this.adb);
 
   const recorder = this.settingsApp.makeMediaProjectionRecorder();
-  const fname = adjustMediaExtension(filename || moment().format(DEFAULT_FILENAME_FORMAT));
+  const fname = adjustMediaExtension(filename || dayjs().format(DEFAULT_FILENAME_FORMAT));
   const didStart = await recorder.start({
     resolution,
     priority,
@@ -128,7 +127,7 @@ export async function mobileStopMediaProjectionRecording(
     throw new Error(`No recent media projection recording have been found. Did you start any?`);
   }
 
-  if (_.isEmpty(remotePath)) {
+  if (util.isEmpty(remotePath)) {
     const {size} = await fs.stat(recentRecordingPath);
     this.log.debug(
       `The size of the resulting media projection recording is ${util.toReadableSizeString(size)}`,
@@ -154,7 +153,7 @@ async function uploadRecordedMedia(
   remotePath?: string,
   uploadOptions: UploadOptions = {},
 ): Promise<string> {
-  if (_.isEmpty(remotePath)) {
+  if (util.isEmpty(remotePath)) {
     return (await util.toInMemoryBase64(localFile)).toString();
   }
 
@@ -182,7 +181,7 @@ async function uploadRecordedMedia(
 }
 
 function adjustMediaExtension(name: string): string {
-  return _.toLower(name).endsWith(DEFAULT_EXT) ? name : `${name}${DEFAULT_EXT}`;
+  return name?.toLowerCase()?.endsWith(DEFAULT_EXT) ? name : `${name}${DEFAULT_EXT}`;
 }
 
 async function verifyMediaProjectionRecordingIsSupported(adb: ADB): Promise<void> {

package/lib/commands/network.ts

@@ -1,4 +1,3 @@
-import _ from 'lodash';
 import {errors} from 'appium/driver';
 import {util} from '@appium/support';
 import type {AndroidDriver} from '../driver';
@@ -69,7 +68,7 @@ export async function mobileSetConnectivity(
   data?: boolean,
   airplaneMode?: boolean,
 ): Promise<void> {
-  if (_.every([wifi, data, airplaneMode], _.isUndefined)) {
+  if (wifi === undefined && data === undefined && airplaneMode === undefined) {
     throw new errors.InvalidArgumentError(
       `Either one of ${JSON.stringify(SUPPORTED_SERVICE_NAMES)} options must be provided`,
     );
@@ -81,20 +80,20 @@ export async function mobileSetConnectivity(
     [airplaneMode, AIRPLANE_MODE_KEY_NAME],
   ];
   const services = connectivityPairs.reduce<ServiceType[]>((acc, [value, key]) => {
-    if (!_.isUndefined(value)) {
+    if (value !== undefined) {
       acc.push(key);
     }
     return acc;
   }, []);
   const currentState = await this.mobileGetConnectivity(services);
   const setters: Promise<any>[] = [];
-  if (!_.isUndefined(wifi) && currentState.wifi !== Boolean(wifi)) {
+  if (wifi !== undefined && currentState.wifi !== Boolean(wifi)) {
     setters.push(this.setWifiState(wifi));
   }
-  if (!_.isUndefined(data) && currentState.data !== Boolean(data)) {
+  if (data !== undefined && currentState.data !== Boolean(data)) {
     setters.push(this.setDataState(data));
   }
-  if (!_.isUndefined(airplaneMode) && currentState.airplaneMode !== Boolean(airplaneMode)) {
+  if (airplaneMode !== undefined && currentState.airplaneMode !== Boolean(airplaneMode)) {
     setters.push(
       (async () => {
         await this.adb.setAirplaneMode(airplaneMode);
@@ -104,7 +103,7 @@ export async function mobileSetConnectivity(
       })(),
     );
   }
-  if (!_.isEmpty(setters)) {
+  if (setters.length > 0) {
     await Promise.all(setters);
   }
 }
@@ -120,9 +119,9 @@ export async function mobileGetConnectivity(
   this: AndroidDriver,
   services: ServiceType[] | ServiceType = SUPPORTED_SERVICE_NAMES,
 ): Promise<GetConnectivityResult> {
-  const svcs = _.castArray(services);
-  const unsupportedServices = _.difference(svcs, SUPPORTED_SERVICE_NAMES);
-  if (!_.isEmpty(unsupportedServices)) {
+  const svcs = Array.isArray(services) ? services : [services];
+  const unsupportedServices = svcs.filter((svc) => !SUPPORTED_SERVICE_NAMES.includes(svc));
+  if (unsupportedServices.length > 0) {
     throw new errors.InvalidArgumentError(
       `${util.pluralize(
         'Service name',
@@ -144,13 +143,13 @@ export async function mobileGetConnectivity(
       : Promise.resolve(undefined),
   ]);
   const result: GetConnectivityResult = {};
-  if (!_.isUndefined(wifi)) {
+  if (wifi !== undefined) {
     result.wifi = Boolean(wifi);
   }
-  if (!_.isUndefined(data)) {
+  if (data !== undefined) {
     result.data = Boolean(data);
   }
-  if (!_.isUndefined(airplaneMode)) {
+  if (airplaneMode !== undefined) {
     result.airplaneMode = Boolean(airplaneMode);
   }
   return result;

package/lib/commands/nfc.ts

@@ -1,5 +1,4 @@
 import {errors} from 'appium/driver';
-import _ from 'lodash';
 import type {AndroidDriver} from '../driver';
 import type {NfcAction} from './types';
 
@@ -27,7 +26,7 @@ export async function mobileNfc(this: AndroidDriver, action: NfcAction): Promise
       break;
     default:
       throw new errors.InvalidArgumentError(
-        `You must provide a valid 'action' argument. Supported actions are: ${_.values(SUPPORTED_ACTIONS)}`,
+        `You must provide a valid 'action' argument. Supported actions are: ${Object.values(SUPPORTED_ACTIONS)}`,
       );
   }
 }

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});