appium-adb 14.3.4 → 14.4.0

package/lib/tools/app-commands.ts

@@ -1,10 +1,10 @@
-import _ from 'lodash';
 import {fs, tempDir, util, system} from '@appium/support';
 import {log} from '../logger';
 import {waitForCondition} from 'asyncbox';
 import path from 'node:path';
 import type {ADB} from '../adb';
 import type {ExecError} from 'teen_process';
+import {defaults, intersectionWith} from '../utils';
 import type {
   StringRecord,
   InstallState,
@@ -79,7 +79,7 @@ export async function resolveLaunchableActivity(
   if (!preferCmd || (await this.getApiLevel()) < 24) {
     const stdout = await this.shell(['dumpsys', 'package', pkg]);
     const names = parseLaunchableActivityNames(stdout);
-    if (_.isEmpty(names)) {
+    if (util.isEmpty(names)) {
       log.debug(stdout);
       throw new Error(
         `Unable to resolve the launchable activity of '${pkg}'. Is it installed on the device?`,
@@ -113,7 +113,7 @@ export async function resolveLaunchableActivity(
       outputFormat: this.EXEC_OUTPUT_FORMAT.FULL,
     },
   );
-  for (const line of (stdout || '').split('\n').map(_.trim)) {
+  for (const line of (stdout || '').split('\n').map((x) => x.trim())) {
     if (this.isValidClass(line)) {
       return line;
     }
@@ -204,8 +204,8 @@ export async function grantAllPermissions(this: ADB, pkg: string, apk?: string):
     dumpsysOutput = dumpsysOutput || (await this.shell(['dumpsys', 'package', pkg]));
     const requestedPermissions = await this.getReqPermissions(pkg, dumpsysOutput);
     const grantedPermissions = await this.getGrantedPermissions(pkg, dumpsysOutput);
-    const permissionsToGrant = _.difference(requestedPermissions, grantedPermissions);
-    if (_.isEmpty(permissionsToGrant)) {
+    const permissionsToGrant = requestedPermissions.filter((x) => !grantedPermissions.includes(x));
+    if (util.isEmpty(permissionsToGrant)) {
       log.info(`${pkg} contains no permissions available for granting`);
     } else {
       await this.grantPermissions(pkg, permissionsToGrant);
@@ -355,7 +355,7 @@ export async function stopAndClear(this: ADB, pkg: string): Promise<void> {
     await this.clear(pkg);
   } catch (e) {
     const err = e as Error;
-    throw new Error(`Cannot stop and clear ${pkg}. Original error: ${err.message}`);
+    throw new Error(`Cannot stop and clear ${pkg}. Original error: ${err.message}`, {cause: e});
   }
 }
 
@@ -378,7 +378,10 @@ export async function getPackageInfo(this: ADB, pkg: string): Promise<AppInfo> {
     return result;
   }
 
-  const installedPattern = new RegExp(`^\\s*Package\\s+\\[${_.escapeRegExp(pkg)}\\][^:]+:$`, 'm');
+  const installedPattern = new RegExp(
+    `^\\s*Package\\s+\\[${util.escapeRegExp(pkg)}\\][^:]+:$`,
+    'm',
+  );
   result.isInstalled = installedPattern.test(stdout);
   if (!result.isInstalled) {
     return result;
@@ -404,9 +407,9 @@ export async function getPackageInfo(this: ADB, pkg: string): Promise<AppInfo> {
  * @throws {Error} If there was an error while fetching the .apk
  */
 export async function pullApk(this: ADB, pkg: string, tmpDir: string): Promise<string> {
-  const stdout = _.trim(await this.shell(['pm', 'path', pkg]));
+  const stdout = (await this.shell(['pm', 'path', pkg])).trim();
   const packageMarker = 'package:';
-  if (!_.startsWith(stdout, packageMarker)) {
+  if (!stdout.startsWith(packageMarker)) {
     throw new Error(`Cannot pull the .apk package for '${pkg}'. Original error: ${stdout}`);
   }
 
@@ -433,7 +436,7 @@ export async function activateApp(this: ADB, appId: string): Promise<void> {
     // The monkey command could raise an issue as https://stackoverflow.com/questions/44860475/how-to-use-the-monkey-command-with-an-android-system-that-doesnt-have-physical
     // but '--pct-syskeys 0' could cause another background process issue. https://github.com/appium/appium/issues/16941#issuecomment-1129837285
     const cmd = ['monkey', '-p', appId, '-c', 'android.intent.category.LAUNCHER', '1'];
-    let output = '';
+    let output: string;
     try {
       output = await this.shell(cmd);
       log.debug(`Command stdout: ${output}`);
@@ -546,8 +549,8 @@ export async function listInstalledPackages(
     const error = e as ExecError;
     // https://github.com/appium/appium-uiautomator2-driver/issues/810
     if (
-      _.includes(error.stderr || error.stdout || error.message, 'access user') &&
-      _.isEmpty(user)
+      (error.stderr || error.stdout || error.message)?.includes('access user') &&
+      util.isEmpty(user)
     ) {
       stdout = await this.shell([...cmd, '--user', '0']);
     } else {
@@ -597,7 +600,8 @@ export async function startUri(
       throw new Error(res);
     }
   } catch (e) {
-    throw new Error(`Error attempting to start URI. Original error: ${e}`);
+    const err = e instanceof Error ? e : new Error(String(e));
+    throw new Error(`Error attempting to start URI. Original error: ${err.message}`, {cause: e});
   }
 }
 
@@ -613,12 +617,12 @@ export async function startApp(this: ADB, startAppOptions: StartAppOptions): Pro
     throw new Error('pkg, and activity or intent action, are required to start an application');
   }
 
-  const options = _.clone(startAppOptions);
+  const options = {...startAppOptions};
   if (options.activity) {
     options.activity = options.activity.replace('$', '\\$');
   }
   // initializing defaults
-  _.defaults(options, {
+  defaults(options, {
     waitPkg: options.pkg,
     waitForLaunch: true,
     waitActivity: false,
@@ -637,7 +641,7 @@ export async function startApp(this: ADB, startAppOptions: StartAppOptions): Pro
     const shellOpts: {timeout?: number} = {};
     if (
       options.waitDuration !== undefined &&
-      _.isInteger(options.waitDuration) &&
+      Number.isInteger(options.waitDuration) &&
       options.waitDuration >= 0
     ) {
       shellOpts.timeout = options.waitDuration;
@@ -683,6 +687,7 @@ export async function startApp(this: ADB, startAppOptions: StartAppOptions): Pro
       `Cannot start the '${appDescriptor}' application. ` +
         `Consider checking the driver's troubleshooting documentation. ` +
         `Original error: ${error.message}`,
+      {cause: e},
     );
   }
 }
@@ -717,6 +722,7 @@ export async function getFocusedPackageAndActivity(this: ADB): Promise<PackageAc
     const error = e as Error;
     throw new Error(
       `Could not retrieve the currently focused package and activity. Original error: ${error.message}`,
+      {cause: e},
     );
   }
 
@@ -750,15 +756,15 @@ export async function getFocusedPackageAndActivity(this: ADB): Promise<PackageAc
   if (focusedAppCandidates.length > 1 && currentFocusAppCandidates.length > 0) {
     // https://github.com/appium/appium/issues/17106
     return (
-      _.intersectionWith(focusedAppCandidates, currentFocusAppCandidates, (value, other) => {
-        if (!_.isEqual(value.appPackage, other.appPackage)) {
+      intersectionWith(focusedAppCandidates, currentFocusAppCandidates, (value, other) => {
+        if (value.appPackage !== other.appPackage) {
           return false;
         }
         // https://github.com/appium/appium-adb/issues/797
         const [thisActivity, otherActivity] = [value.appActivity, other.appActivity].map((name) =>
           name?.replace(value.appPackage || '', ''),
         );
-        return Boolean(thisActivity && otherActivity && _.isEqual(thisActivity, otherActivity));
+        return Boolean(thisActivity && otherActivity && thisActivity === otherActivity);
       })[0] ?? focusedAppCandidates[0]
     );
   }
@@ -801,7 +807,7 @@ export async function waitForActivityOrNot(
     throw new Error('Package and activity required.');
   }
 
-  const splitNames = (names: string) => names.split(',').map(_.trim);
+  const splitNames = (names: string) => names.split(',').map((x) => x.trim());
   const allPackages = splitNames(pkg);
   const allActivities = splitNames(activity);
 
@@ -860,7 +866,7 @@ export async function waitForActivityOrNot(
       );
       log.debug(`Focused fully qualified activity name: ${fullyQualifiedActivity}`);
       const isFound =
-        _.includes(allPackages, appPackage) &&
+        allPackages.includes(appPackage) &&
         possibleActivityPatterns.some((p) => p.test(fullyQualifiedActivity));
       if ((!waitForStop && isFound) || (waitForStop && !isFound)) {
         return true;
@@ -984,36 +990,36 @@ export function buildStartCmd(startAppOptions: StartCmdOptions, apiLevel: number
  * in order to determine category names for these.
  */
 export function parseLaunchableActivityNames(dumpsys: string): string[] {
-  const mainActivityNameRe = new RegExp(`^\\s*${_.escapeRegExp(MAIN_ACTION)}:$`);
+  const mainActivityNameRe = new RegExp(`^\\s*${util.escapeRegExp(MAIN_ACTION)}:$`);
   const categoryNameRe = /^\s*Category:\s+"([a-zA-Z0-9._/-]+)"$/;
   const blocks: string[][] = [];
   let blockStartIndent: number | null | undefined;
   let block: string[] = [];
-  for (const line of dumpsys.split('\n').map(_.trimEnd)) {
-    const currentIndent = line.length - _.trimStart(line).length;
+  for (const line of dumpsys.split('\n').map((x) => x.trimEnd())) {
+    const currentIndent = line.length - line.trimStart().length;
     if (mainActivityNameRe.test(line)) {
       blockStartIndent = currentIndent;
-      if (!_.isEmpty(block)) {
+      if (!util.isEmpty(block)) {
         blocks.push(block);
         block = [];
       }
       continue;
     }
-    if (_.isNil(blockStartIndent)) {
+    if (blockStartIndent == null) {
       continue;
     }
 
     if (currentIndent > blockStartIndent) {
       block.push(line);
     } else {
-      if (!_.isEmpty(block)) {
+      if (!util.isEmpty(block)) {
         blocks.push(block);
         block = [];
       }
       blockStartIndent = null;
     }
   }
-  if (!_.isEmpty(block)) {
+  if (!util.isEmpty(block)) {
     blocks.push(block);
   }
 
@@ -1038,7 +1044,7 @@ export function parseLaunchableActivityNames(dumpsys: string): string[] {
       continue;
     }
 
-    for (const activityNameStr of item.map(_.trim).filter(Boolean)) {
+    for (const activityNameStr of item.map((x) => x.trim()).filter(Boolean)) {
       const fqActivityName = activityNameStr.split(/\s+/)[1];
       if (!matchComponentName(fqActivityName)) {
         continue;
@@ -1080,7 +1086,7 @@ export function extractMatchingPermissions(
   grantedState: boolean | null = null,
 ): string[] {
   const groupPatternByName = (groupName: string) =>
-    new RegExp(`^(\\s*${_.escapeRegExp(groupName)} permissions:[\\s\\S]+)`, 'm');
+    new RegExp(`^(\\s*${util.escapeRegExp(groupName)} permissions:[\\s\\S]+)`, 'm');
   const indentPattern = /\S|$/;
   const permissionNamePattern = /android\.\w*\.?permission\.\w+/;
   const grantedStatePattern = /\bgranted=(\w+)/;
@@ -1119,7 +1125,7 @@ export function extractMatchingPermissions(
   }
 
   const filteredResult = result
-    .filter((item) => !_.isBoolean(grantedState) || item.granted === grantedState)
+    .filter((item) => typeof grantedState !== 'boolean' || item.granted === grantedState)
     .map((item) => item.permission);
   log.debug(
     `Retrieved ${util.pluralize('permission', filteredResult.length, true)} ` +
@@ -1150,14 +1156,14 @@ export async function broadcast(this: ADB, intent: string): Promise<void> {
  */
 export async function listAppProcessIds(this: ADB, pkg: string): Promise<number[]> {
   log.debug(`Getting IDs of all '${pkg}' package`);
-  const pidRegex = new RegExp(`ProcessRecord\\{[\\w]+\\s+(\\d+):${_.escapeRegExp(pkg)}\\/`);
+  const pidRegex = new RegExp(`ProcessRecord\\{[\\w]+\\s+(\\d+):${util.escapeRegExp(pkg)}\\/`);
   const processesInfo = await this.shell(['dumpsys', 'activity', 'processes']);
   const pids = processesInfo
     .split('\n')
     .map((line) => line.match(pidRegex))
     .filter((match) => !!match)
     .map(([, pidStr]) => parseInt(pidStr, 10));
-  return _.uniq(pids);
+  return util.uniq(pids);
 }
 
 /**
@@ -1168,7 +1174,7 @@ export async function listAppProcessIds(this: ADB, pkg: string): Promise<number[
  * @returns True if the given package is running.
  */
 export async function isAppRunning(this: ADB, pkg: string): Promise<boolean> {
-  return !_.isEmpty(await this.listAppProcessIds(pkg));
+  return !util.isEmpty(await this.listAppProcessIds(pkg));
 }
 
 /**

package/lib/tools/device-settings.ts

@@ -1,5 +1,4 @@
 import {log} from '../logger';
-import _ from 'lodash';
 import {retryInterval} from 'asyncbox';
 import {util} from '@appium/support';
 import type {ADB} from '../adb';
@@ -155,10 +154,10 @@ export async function setHttpProxy(
   proxyPort: string | number,
 ): Promise<void> {
   const proxy = `${proxyHost}:${proxyPort}`;
-  if (_.isUndefined(proxyHost)) {
+  if (typeof proxyHost === 'undefined') {
     throw new Error(`Call to setHttpProxy method with undefined proxy_host: ${proxy}`);
   }
-  if (_.isUndefined(proxyPort)) {
+  if (typeof proxyPort === 'undefined') {
     throw new Error(`Call to setHttpProxy method with undefined proxy_port ${proxy}`);
   }
 
@@ -231,7 +230,7 @@ export async function getTimeZone(this: ADB): Promise<string> {
     return await this.getDeviceProperty('persist.sys.timezone');
   } catch (e) {
     const err = e as Error;
-    throw new Error(`Error getting timezone. Original error: ${err.message}`);
+    throw new Error(`Error getting timezone. Original error: ${err.message}`, {cause: e});
   }
 }
 
@@ -247,7 +246,9 @@ export async function getPlatformVersion(this: ADB): Promise<string> {
     return await this.getDeviceProperty('ro.build.version.release');
   } catch (e) {
     const err = e as Error;
-    throw new Error(`Error getting device platform version. ` + `Original error: ${err.message}`);
+    throw new Error(`Error getting device platform version. ` + `Original error: ${err.message}`, {
+      cause: e,
+    });
   }
 }
 
@@ -268,7 +269,7 @@ export async function getLocationProviders(this: ADB): Promise<string[]> {
   }
 
   // To emulate the legacy behavior
-  return _.includes(await this.shell(['cmd', 'location', 'is-location-enabled']), 'true')
+  return (await this.shell(['cmd', 'location', 'is-location-enabled'])).includes('true')
     ? ['gps']
     : [];
 }
@@ -401,8 +402,8 @@ export async function ensureCurrentLocale(
   country?: string,
   script?: string,
 ): Promise<boolean> {
-  const hasLanguage = _.isString(language);
-  const hasCountry = _.isString(country);
+  const hasLanguage = typeof language === 'string';
+  const hasCountry = typeof country === 'string';
   if (!hasLanguage && !hasCountry) {
     log.warn('ensureCurrentLocale requires language or country');
     return false;
@@ -439,12 +440,12 @@ export async function ensureCurrentLocale(
         ? `${lcLanguage}-${script.toLowerCase()}-${lcCountry}`
         : `${lcLanguage}-${lcCountry}`;
       log.debug(`Requested locale: ${expectedLocale}. Actual locale: '${actualLocale}'`);
-      const languagePattern = `^${_.escapeRegExp(lcLanguage)}-${script ? _.escapeRegExp(script) + '-' : ''}`;
+      const languagePattern = `^${util.escapeRegExp(lcLanguage)}-${script ? util.escapeRegExp(script) + '-' : ''}`;
       const checkLocalePattern = (p: string) => new RegExp(p, 'i').test(actualLocale);
       if (hasLanguage && !hasCountry) {
         return checkLocalePattern(languagePattern);
       }
-      const countryPattern = `${script ? '-' + _.escapeRegExp(script) : ''}-${_.escapeRegExp(lcCountry)}$`;
+      const countryPattern = `${script ? '-' + util.escapeRegExp(script) : ''}-${util.escapeRegExp(lcCountry)}$`;
       if (!hasLanguage && hasCountry) {
         return checkLocalePattern(countryPattern);
       }
@@ -509,9 +510,10 @@ export async function getDeviceIdleWhitelist(this: ADB): Promise<string[]> {
 
   log.info('Listing packages in Doze whitelist');
   const output = await this.shell(['dumpsys', 'deviceidle', 'whitelist']);
-  return _.trim(output)
+  return output
+    .trim()
     .split(/\n/)
-    .map((line) => _.trim(line))
+    .map((line) => line.trim())
     .filter(Boolean);
 }
 
@@ -525,7 +527,7 @@ export async function getDeviceIdleWhitelist(this: ADB): Promise<string[]> {
  * @returns `true` if the command to add package(s) has been executed
  */
 export async function addToDeviceIdleWhitelist(this: ADB, ...packages: string[]): Promise<boolean> {
-  if (_.isEmpty(packages) || (await this.getApiLevel()) < 23) {
+  if (util.isEmpty(packages) || (await this.getApiLevel()) < 23) {
     // Doze mode has only been added since Android 6
     return false;
   }
@@ -621,7 +623,7 @@ export async function broadcastAirplaneMode(this: ADB, on: boolean): Promise<voi
   } catch (e) {
     const err = e as ExecError;
     // https://github.com/appium/appium/issues/17422
-    if (_.includes(err.stderr, 'SecurityException')) {
+    if ((err.stderr ?? '').includes('SecurityException')) {
       try {
         await this.shell(args, {privileged: true});
         return;
@@ -708,7 +710,7 @@ export async function getScreenOrientation(this: ADB): Promise<number | null> {
  * @returns Either the same error or the decorated one
  */
 function decorateWriteSecureSettingsException(e: Error): Error {
-  if (_.includes(e.message, 'requires:android.permission.WRITE_SECURE_SETTINGS')) {
+  if (e.message?.includes('requires:android.permission.WRITE_SECURE_SETTINGS')) {
     e.message = `Check https://github.com/appium/appium/issues/13802 for throubleshooting. ${e.message}`;
   }
   return e;

package/lib/tools/emulator-commands.ts

@@ -1,5 +1,4 @@
 import {log} from '../logger';
-import _ from 'lodash';
 import net from 'node:net';
 import {util, fs} from '@appium/support';
 import path from 'node:path';
@@ -25,7 +24,7 @@ import type {
  */
 export async function isEmulatorConnected(this: ADB): Promise<boolean> {
   const emulators = await this.getConnectedEmulators();
-  return !!_.find(emulators, (x) => x && x.udid === this.curDeviceId);
+  return emulators.some((x) => x && x.udid === this.curDeviceId);
 }
 
 /**
@@ -71,10 +70,10 @@ export async function rotate(this: ADB): Promise<void> {
  * @param state - Either 'on' or 'off'.
  */
 export async function powerAC(this: ADB, state: PowerAcStates = 'on'): Promise<void> {
-  if (_.values(this.POWER_AC_STATES).indexOf(state) === -1) {
+  if (!(Object.values(this.POWER_AC_STATES) as string[]).includes(state)) {
     throw new TypeError(
       `Wrong power AC state sent '${state}'. ` +
-        `Supported values: ${_.values(this.POWER_AC_STATES)}]`,
+        `Supported values: ${Object.values(this.POWER_AC_STATES)}]`,
     );
   }
   await this.adbExecEmu(['power', 'ac', state]);
@@ -88,12 +87,12 @@ export async function powerAC(this: ADB, state: PowerAcStates = 'on'): Promise<v
  * @throws - If sensor type or sensor value is not defined
  */
 export async function sensorSet(this: ADB, sensor: string, value: Sensors): Promise<void> {
-  if (!_.includes(this.SENSORS, sensor)) {
+  if (!(Object.values(this.SENSORS) as string[]).includes(sensor)) {
     throw new TypeError(
-      `Unsupported sensor sent '${sensor}'. ` + `Supported values: ${_.values(this.SENSORS)}]`,
+      `Unsupported sensor sent '${sensor}'. ` + `Supported values: ${Object.values(this.SENSORS)}]`,
     );
   }
-  if (_.isNil(value)) {
+  if (value == null) {
     throw new TypeError(
       `Missing/invalid sensor value argument. ` +
         `You need to provide a valid value to set to the sensor in ` +
@@ -136,10 +135,10 @@ export async function sendSMS(
   phoneNumber: string | number,
   message = '',
 ): Promise<void> {
-  if (_.isEmpty(message)) {
+  if (!message) {
     throw new TypeError('SMS message must not be empty');
   }
-  if (!_.isInteger(phoneNumber) && _.isEmpty(phoneNumber)) {
+  if (!Number.isInteger(phoneNumber) && util.isEmpty(phoneNumber)) {
     throw new TypeError('Phone number most not be empty');
   }
   await this.adbExecEmu(['sms', 'send', `${phoneNumber}`, message]);
@@ -158,12 +157,12 @@ export async function gsmCall(
   phoneNumber: string | number,
   action: GsmCallActions,
 ): Promise<void> {
-  if (!_.values(this.GSM_CALL_ACTIONS).includes(action)) {
+  if (!Object.values(this.GSM_CALL_ACTIONS).includes(action)) {
     throw new TypeError(
-      `Invalid gsm action param ${action}. Supported values: ${_.values(this.GSM_CALL_ACTIONS)}`,
+      `Invalid gsm action param ${action}. Supported values: ${Object.values(this.GSM_CALL_ACTIONS)}`,
     );
   }
-  if (!_.isInteger(phoneNumber) && _.isEmpty(phoneNumber)) {
+  if (!Number.isInteger(phoneNumber) && util.isEmpty(phoneNumber)) {
     throw new TypeError('Phone number most not be empty');
   }
   await this.adbExecEmu(['gsm', action, `${phoneNumber}`]);
@@ -177,9 +176,9 @@ export async function gsmCall(
  */
 export async function gsmSignal(this: ADB, strength: GsmSignalStrength = 4): Promise<void> {
   const strengthInt = parseInt(`${strength}`, 10);
-  if (!_.includes(this.GSM_SIGNAL_STRENGTHS, strengthInt)) {
+  if (!(this.GSM_SIGNAL_STRENGTHS as readonly number[]).includes(strengthInt)) {
     throw new TypeError(
-      `Invalid signal strength param ${strength}. Supported values: ${_.values(this.GSM_SIGNAL_STRENGTHS)}`,
+      `Invalid signal strength param ${strength}. Supported values: ${Object.values(this.GSM_SIGNAL_STRENGTHS)}`,
     );
   }
   log.info('gsm signal-profile <strength> changes the reported strength on next (15s) update.');
@@ -194,9 +193,9 @@ export async function gsmSignal(this: ADB, strength: GsmSignalStrength = 4): Pro
  */
 export async function gsmVoice(this: ADB, state: GsmVoiceStates = 'on'): Promise<void> {
   // gsm voice <state> allows you to change the state of your GPRS connection
-  if (!_.values(this.GSM_VOICE_STATES).includes(state)) {
+  if (!Object.values(this.GSM_VOICE_STATES).includes(state)) {
     throw new TypeError(
-      `Invalid gsm voice state param ${state}. Supported values: ${_.values(this.GSM_VOICE_STATES)}`,
+      `Invalid gsm voice state param ${state}. Supported values: ${Object.values(this.GSM_VOICE_STATES)}`,
     );
   }
   await this.adbExecEmu(['gsm', 'voice', state]);
@@ -211,9 +210,9 @@ export async function gsmVoice(this: ADB, state: GsmVoiceStates = 'on'): Promise
  */
 export async function networkSpeed(this: ADB, speed: NetworkSpeed = 'full'): Promise<void> {
   // network speed <speed> allows you to set the network speed emulation.
-  if (!_.values(this.NETWORK_SPEED).includes(speed)) {
+  if (!Object.values(this.NETWORK_SPEED).includes(speed)) {
     throw new Error(
-      `Invalid network speed param ${speed}. Supported values: ${_.values(this.NETWORK_SPEED)}`,
+      `Invalid network speed param ${speed}. Supported values: ${Object.values(this.NETWORK_SPEED)}`,
     );
   }
   await this.adbExecEmu(['network', 'speed', speed]);
@@ -306,7 +305,7 @@ export async function execEmuConsoleCommand(
         if (!isCommandSent) {
           clearTimeout(initTimeoutObj);
           serverResponse = [];
-          const cmdStr = _.isArray(cmd) ? util.quote(cmd) : `${cmd}`;
+          const cmdStr = Array.isArray(cmd) ? util.quote(cmd) : `${cmd}`;
           log.debug(`Executing Emulator console command: ${cmdStr}`);
           client.write(cmdStr);
           client.write(eol);
@@ -338,7 +337,7 @@ export async function execEmuConsoleCommand(
         clearTimeout(execTimeoutObj);
         client.end();
         const outputArr = output.split(eol);
-        return reject(_.trim(_.last(outputArr) || ''));
+        return reject((outputArr.at(-1) || '').trim());
       }
     });
   });
@@ -386,7 +385,7 @@ export async function getEmuImageProperties(this: ADB, avdName: string): Promise
   const avd = avds.find(({name}) => name === avdName);
   if (!avd) {
     let msg = `Cannot find '${avdName}' emulator. `;
-    if (_.isEmpty(avds)) {
+    if (avds.length === 0) {
       msg += `No emulators have been detected on your system`;
     } else {
       msg += `Available avd names are: ${avds.map(({name}) => name)}`;
@@ -407,7 +406,7 @@ export async function checkAvdExist(this: ADB, avdName: string): Promise<boolean
   const avds = await listEmulators();
   if (!avds.some(({name}) => name === avdName)) {
     let msg = `Avd '${avdName}' is not available. `;
-    if (_.isEmpty(avds)) {
+    if (avds.length === 0) {
       msg += `No emulators have been detected on your system`;
     } else {
       msg += `Please select your avd name from one of these: '${avds.map(({name}) => name)}'`;
@@ -476,7 +475,7 @@ async function getAvdConfigPaths(avdsRoot: string): Promise<EmuInfo[]> {
       const avdName = path.basename(confPath).split('.').slice(0, -1).join('.');
       return {name: avdName, config: confPath};
     })
-    .filter(({name}) => _.trim(name));
+    .filter(({name}) => name?.trim());
 }
 
 /**

package/lib/tools/fs-commands.ts

@@ -1,4 +1,3 @@
-import _ from 'lodash';
 import path from 'node:path';
 import type {ADB} from '../adb';
 import type {TeenProcessExecOptions} from 'teen_process';
@@ -13,7 +12,7 @@ export async function fileExists(this: ADB, remotePath: string): Promise<boolean
   const passFlag = '__PASS__';
   const checkCmd = `[ -e '${shellEscapeSingleQuotes(remotePath)}' ] && echo ${passFlag}`;
   try {
-    return _.includes(await this.shell([checkCmd]), passFlag);
+    return (await this.shell([checkCmd])).includes(passFlag);
   } catch {
     return false;
   }
@@ -60,12 +59,14 @@ export async function fileSize(this: ADB, remotePath: string): Promise<number> {
     }
     // https://regex101.com/r/fOs4P4/8
     const match = /[rwxsStT\-+]{10}[\s\d]*\s[^\s]+\s+[^\s]+\s+(\d+)/.exec(files[0]);
-    if (!match || _.isNaN(parseInt(match[1], 10))) {
+    if (!match || Number.isNaN(parseInt(match[1], 10))) {
       throw new Error(`Unable to parse size from list output: '${files[0]}'`);
     }
     return parseInt(match[1], 10);
   } catch (err) {
-    throw new Error(`Unable to get file size for '${remotePath}': ${(err as Error).message}`);
+    throw new Error(`Unable to get file size for '${remotePath}': ${(err as Error).message}`, {
+      cause: err,
+    });
   }
 }
 

package/lib/tools/general-commands.ts

@@ -1,9 +1,9 @@
 import {log} from '../logger';
-import _ from 'lodash';
 import {fs, util} from '@appium/support';
 import {SubProcess, exec, type ExecError} from 'teen_process';
 import type {ADB} from '../adb';
 import type {ScreenrecordOptions, StringRecord} from './types';
+import {memoize} from '../utils';
 
 /**
  * Get the path to adb executable amd assign it
@@ -64,33 +64,37 @@ export async function initBundletool(this: ADB): Promise<void> {
  * calls return the same value as the first one.
  */
 export async function getApiLevel(this: ADB): Promise<number> {
-  if (!_.isInteger(this._apiLevel)) {
-    try {
-      const strOutput = await this.getDeviceProperty('ro.build.version.sdk');
-      let apiLevel = parseInt(strOutput.trim(), 10);
+  if (Number.isInteger(this._apiLevel)) {
+    return this._apiLevel as number;
+  }
 
-      // Workaround for preview/beta platform API level
-      const charCodeQ = 'q'.charCodeAt(0);
-      // 28 is the first API Level, where Android SDK started returning letters in response to getPlatformVersion
-      const apiLevelDiff = apiLevel - 28;
-      const codename = String.fromCharCode(charCodeQ + apiLevelDiff);
-      if (apiLevelDiff >= 0 && (await this.getPlatformVersion()).toLowerCase() === codename) {
-        log.debug(
-          `Release version is ${codename.toUpperCase()} but found API Level ${apiLevel}. Setting API Level to ${apiLevel + 1}`,
-        );
-        apiLevel++;
-      }
+  try {
+    const strOutput = await this.getDeviceProperty('ro.build.version.sdk');
+    let apiLevel = parseInt(strOutput.trim(), 10);
 
-      this._apiLevel = apiLevel;
-      log.debug(`Device API level: ${this._apiLevel}`);
-      if (isNaN(this._apiLevel)) {
-        throw new Error(`The actual output '${strOutput}' cannot be converted to an integer`);
-      }
-    } catch (e) {
-      throw new Error(`Error getting device API level. Original error: ${(e as Error).message}`);
+    // Workaround for preview/beta platform API level
+    const charCodeQ = 'q'.charCodeAt(0);
+    // 28 is the first API Level, where Android SDK started returning letters in response to getPlatformVersion
+    const apiLevelDiff = apiLevel - 28;
+    const codename = String.fromCharCode(charCodeQ + apiLevelDiff);
+    if (apiLevelDiff >= 0 && (await this.getPlatformVersion()).toLowerCase() === codename) {
+      log.debug(
+        `Release version is ${codename.toUpperCase()} but found API Level ${apiLevel}. Setting API Level to ${apiLevel + 1}`,
+      );
+      apiLevel++;
     }
+
+    this._apiLevel = apiLevel;
+    log.debug(`Device API level: ${this._apiLevel}`);
+    if (isNaN(this._apiLevel)) {
+      throw new Error(`The actual output '${strOutput}' cannot be converted to an integer`);
+    }
+    return this._apiLevel;
+  } catch (e) {
+    throw new Error(`Error getting device API level. Original error: ${(e as Error).message}`, {
+      cause: e,
+    });
   }
-  return this._apiLevel as number;
 }
 
 /**
@@ -164,7 +168,7 @@ export async function restart(this: ADB): Promise<void> {
     await this.startLogcat(this._logcatStartupParams);
   } catch (e) {
     const err = e as Error;
-    throw new Error(`Restart failed. Original error: ${err.message}`);
+    throw new Error(`Restart failed. Original error: ${err.message}`, {cause: e});
   }
 }
 
@@ -235,7 +239,7 @@ export function screenrecord(
 export async function listFeatures(this: ADB): Promise<string[]> {
   this._memoizedFeatures =
     this._memoizedFeatures ||
-    _.memoize(
+    memoize(
       async () => await this.adbExec(['features']),
       () => this.curDeviceId,
     );
@@ -250,7 +254,7 @@ export async function listFeatures(this: ADB): Promise<string[]> {
       .filter(Boolean);
   } catch (e) {
     const err = e as ExecError;
-    if (_.includes(err.stderr, 'unknown command')) {
+    if ((err.stderr ?? '').includes('unknown command')) {
       return [];
     }
     throw err;
@@ -327,6 +331,7 @@ export async function takeScreenshot(this: ADB, displayId?: number | string): Pr
     throw new Error(
       `Screenshot of the ${displayDescr} failed. ` +
         `Code: '${err.code ?? 'unknown'}', output: '${outputStr}'`,
+      {cause: e},
     );
   }
   if (stdout.length === 0) {