Revert "feat: Cleanup deprecated/unused entities and add method overloads (#876)"

This reverts commit 21ece85.

Author: mykola-mokhnach

lib/adb.ts

@@ -206,11 +206,12 @@ export class ADB implements ADBOptions {
   killServer = systemCommands.killServer;
   resetTelnetAuthToken = systemCommands.resetTelnetAuthToken;
   adbExecEmu = systemCommands.adbExecEmu;
-  EXEC_OUTPUT_FORMAT: typeof systemCommands.EXEC_OUTPUT_FORMAT = systemCommands.EXEC_OUTPUT_FORMAT;
+  EXEC_OUTPUT_FORMAT = systemCommands.EXEC_OUTPUT_FORMAT;
   adbExec = systemCommands.adbExec;
   shell = systemCommands.shell;
   shellChunks = systemCommands.shellChunks;
   createSubProcess = systemCommands.createSubProcess;
+  getAdbServerPort = systemCommands.getAdbServerPort;
   getEmulatorPort = systemCommands.getEmulatorPort;
   getPortFromEmulatorString = systemCommands.getPortFromEmulatorString;
   getConnectedEmulators = systemCommands.getConnectedEmulators;

lib/tools/apk-signing.ts

@@ -250,12 +250,14 @@ export async function zipAlignApk(this: ADB, apk: string): Promise<boolean> {
  * Check if the app is already signed with the default Appium certificate.
  *
  * @param appPath - The full path to the local .apk(s) file.
+ * @param pkg - The name of application package.
  * @param opts - Certificate checking options
  * @returns True if given application is already signed.
  */
 export async function checkApkCert(
   this: ADB,
   appPath: string,
+  pkg: string,
   opts: CertCheckOptions = {},
 ): Promise<boolean> {
   log.debug(`Checking app cert for ${appPath}`);

lib/tools/device-settings.ts

@@ -586,9 +586,9 @@ export async function setBluetoothOn(this: ADB, on: boolean): Promise<void> {
  * @throws If there was an error while changing the service state
  */
 export async function setNfcOn(this: ADB, on: boolean): Promise<void> {
-  const {stdout, stderr} = await this.shell(['svc', 'nfc', on ? 'enable' : 'disable'], {
+  const {stdout, stderr} = (await this.shell(['svc', 'nfc', on ? 'enable' : 'disable'], {
     outputFormat: 'full',
-  });
+  })) as {stdout: string; stderr: string};
   const output = stderr || stdout;
   log.debug(output);
   if (output.includes('null NfcAdapter')) {

lib/tools/system-calls.ts

@@ -10,17 +10,15 @@ import {DEFAULT_ADB_EXEC_TIMEOUT, cloneDeep, getSdkRootFromEnv, memoize, zip} fr
 import type {
   ConnectedDevicesOptions,
   Device,
-  VerboseDevice,
   AvdLaunchOptions,
   Version,
   RootResult,
   ShellExecOptions,
   SpecialAdbExecOptions,
+  TFullOutputOption,
   ExecResult,
 } from './types';
 
-type AdbExecOptions = ShellExecOptions & SpecialAdbExecOptions;
-
 const DEFAULT_ADB_REBOOT_RETRIES = 90;
 const LINKER_WARNING_REGEXP = /^WARNING: linker.+$/m;
 const ADB_RETRY_ERROR_PATTERNS = [
@@ -211,32 +209,17 @@ export async function getBinaryFromPath(this: ADB, binaryName: string): Promise<
   }
 }
 
-/**
- * Retrieve the list of devices visible to adb.
- *
- * @param opts - Options with `verbose: true` for long `adb devices -l` output
- * @returns Array of connected devices with product/model metadata
- * @throws {Error} If adb devices command fails or returns unexpected output
- */
-export async function getConnectedDevices(
-  this: ADB,
-  opts: ConnectedDevicesOptions & {verbose: true},
-): Promise<VerboseDevice[]>;
 /**
  * Retrieve the list of devices visible to adb.
  *
  * @param opts - Options for device retrieval
  * @returns Array of connected devices
  * @throws {Error} If adb devices command fails or returns unexpected output
  */
-export async function getConnectedDevices(
-  this: ADB,
-  opts?: ConnectedDevicesOptions,
-): Promise<Device[]>;
 export async function getConnectedDevices(
   this: ADB,
   opts: ConnectedDevicesOptions = {},
-): Promise<Device[] | VerboseDevice[]> {
+): Promise<Device[]> {
   log.debug('Getting connected devices');
   const args = [...this.executable.defaultArgs, 'devices'];
   if (opts.verbose) {
@@ -273,32 +256,15 @@ export async function getConnectedDevices(
     .map((line) => {
       // state is "device", afaic
       const [udid, state, ...description] = line.split(/\s+/);
-      if (!opts.verbose) {
-        return {udid, state};
-      }
-      const device: VerboseDevice = {
-        udid,
-        state,
-        product: '',
-        model: '',
-        device: '',
-      };
-      for (const entry of description) {
-        if (!entry.includes(':')) {
-          continue;
-        }
-        // each entry looks like key:value
-        const [key, value] = entry.split(':');
-        if (key === 'product') {
-          device.product = value;
-        } else if (key === 'model') {
-          device.model = value;
-        } else if (key === 'device') {
-          device.device = value;
-        } else if (key === 'usb') {
-          device.usb = value;
-        } else if (key === 'transport_id') {
-          device.transport_id = value;
+      const device: Device & Record<string, string> = {udid, state} as Device &
+        Record<string, string>;
+      if (opts.verbose) {
+        for (const entry of description) {
+          if (entry.includes(':')) {
+            // each entry looks like key:value
+            const [key, value] = entry.split(':');
+            device[key] = value;
+          }
         }
       }
       return device;
@@ -467,42 +433,27 @@ export const EXEC_OUTPUT_FORMAT = {
   FULL: 'full',
 } as const;
 
-/**
- * Execute the given adb command.
- *
- * @param cmd - Command string or array of command arguments
- * @param opts - Execution options with `outputFormat: 'full'`
- * @returns Command stdout and stderr
- * @throws {Error} If command execution fails or timeout is exceeded
- */
-export async function adbExec(
-  this: ADB,
-  cmd: string | string[],
-  opts: AdbExecOptions & {outputFormat: 'full'},
-): Promise<ExecResult>;
 /**
  * Execute the given adb command.
  *
  * @param cmd - Command string or array of command arguments
  * @param opts - Execution options
- * @returns Command stdout
+ * @returns Command output (string or ExecResult depending on outputFormat)
  * @throws {Error} If command execution fails or timeout is exceeded
  */
-export async function adbExec(
+export async function adbExec<
+  TExecOpts extends ShellExecOptions & SpecialAdbExecOptions = ShellExecOptions &
+    SpecialAdbExecOptions,
+>(
   this: ADB,
   cmd: string | string[],
-  opts?: AdbExecOptions,
-): Promise<string>;
-export async function adbExec(
-  this: ADB,
-  cmd: string | string[],
-  opts?: AdbExecOptions,
-): Promise<string | ExecResult> {
+  opts?: TExecOpts,
+): Promise<TExecOpts extends TFullOutputOption ? ExecResult : string> {
   if (!cmd) {
     throw new Error('You need to pass in a command to adbExec()');
   }
 
-  const optsCopy = cloneDeep(opts ?? {}) as AdbExecOptions;
+  const optsCopy = cloneDeep(opts ?? {}) as TExecOpts;
   // setting default timeout for each command to prevent infinite wait.
   optsCopy.timeout = optsCopy.timeout || this.adbExecTimeout || DEFAULT_ADB_EXEC_TIMEOUT;
   optsCopy.timeoutCapName = optsCopy.timeoutCapName || 'adbExecTimeout'; // For error message
@@ -572,46 +523,28 @@ export async function adbExec(
     isExecLocked = true;
   }
   try {
-    return await execFunc();
+    return (await execFunc()) as TExecOpts extends TFullOutputOption ? ExecResult : string;
   } finally {
     if (optsCopy.exclusive) {
       isExecLocked = false;
     }
   }
 }
 
-/**
- * Execute the given command using _adb shell_ prefix.
- *
- * @param cmd - Command string or array of command arguments
- * @param opts - Execution options with `outputFormat: 'full'`
- * @returns Command stdout and stderr
- * @throws {Error} If command execution fails
- */
-export async function shell(
-  this: ADB,
-  cmd: string | string[],
-  opts: ShellExecOptions & {outputFormat: 'full'},
-): Promise<ExecResult>;
 /**
  * Execute the given command using _adb shell_ prefix.
  *
  * @param cmd - Command string or array of command arguments
  * @param opts - Execution options
- * @returns Command stdout
+ * @returns Command output (string or ExecResult depending on outputFormat)
  * @throws {Error} If command execution fails
  */
-export async function shell(
-  this: ADB,
-  cmd: string | string[],
-  opts?: ShellExecOptions,
-): Promise<string>;
-export async function shell(
+export async function shell<TShellExecOpts extends ShellExecOptions = ShellExecOptions>(
   this: ADB,
   cmd: string | string[],
-  opts?: ShellExecOptions,
-): Promise<string | ExecResult> {
-  const {privileged} = opts ?? {};
+  opts?: TShellExecOpts,
+): Promise<TShellExecOpts extends TFullOutputOption ? ExecResult : string> {
+  const {privileged} = opts ?? ({} as TShellExecOpts);
 
   const cmdArr = Array.isArray(cmd) ? cmd : [cmd];
   const fullCmd: string[] = ['shell'];
@@ -642,6 +575,17 @@ export function createSubProcess(this: ADB, args: string[] = []): SubProcess {
   return new SubProcess(this.getAdbPath(), finalArgs);
 }
 
+/**
+ * Retrieve the current adb port.
+ * @todo can probably deprecate this now that the logic is just to read this.adbPort
+ * @deprecated Use this.adbPort instead
+ *
+ * @returns The ADB server port number
+ */
+export function getAdbServerPort(this: ADB): number {
+  return this.adbPort as number;
+}
+
 /**
  * Retrieve the current emulator port from _adb devices_ output.
  *
@@ -679,38 +623,21 @@ export function getPortFromEmulatorString(this: ADB, emStr: string): number | fa
   return match ? parseInt(match[1], 10) : false;
 }
 
-/**
- * Retrieve the list of currently connected emulators.
- *
- * @param opts - Options with `verbose: true` for long `adb devices -l` output
- * @returns Array of connected emulator devices with product/model metadata
- * @throws {Error} If error occurs while getting emulators
- */
-export async function getConnectedEmulators(
-  this: ADB,
-  opts: ConnectedDevicesOptions & {verbose: true},
-): Promise<VerboseDevice[]>;
 /**
  * Retrieve the list of currently connected emulators.
  *
  * @param opts - Options for device retrieval
  * @returns Array of connected emulator devices
  * @throws {Error} If error occurs while getting emulators
  */
-export async function getConnectedEmulators(
-  this: ADB,
-  opts?: ConnectedDevicesOptions,
-): Promise<Device[]>;
 export async function getConnectedEmulators(
   this: ADB,
   opts: ConnectedDevicesOptions = {},
-): Promise<Device[] | VerboseDevice[]> {
+): Promise<Device[]> {
   log.debug('Getting connected emulators');
   try {
-    const devices = opts.verbose
-      ? await this.getConnectedDevices({verbose: true})
-      : await this.getConnectedDevices(opts);
-    const emulators: Array<Device | VerboseDevice> = [];
+    const devices = await this.getConnectedDevices(opts);
+    const emulators: Device[] = [];
     for (const device of devices) {
       const port = this.getPortFromEmulatorString(device.udid);
       if (port) {

lib/tools/types.ts

@@ -658,6 +658,8 @@ export interface ShellExecOptions {
   outputFormat?: ExecOutputFormat;
 }
 
+export type TFullOutputOption = {outputFormat: 'full'};
+
 export interface AvdLaunchOptions {
   /**
    * Additional emulator command line arguments

test/functional/apk-signing-e2e-specs.ts

@@ -2,7 +2,7 @@ import {ADB} from '../../lib/adb';
 import path from 'node:path';
 import {fs, tempDir} from '@appium/support';
 import {unsignApk} from '../../lib/tools/apk-signing';
-import {getApiDemosPath} from './setup';
+import {APIDEMOS_PKG, getApiDemosPath} from './setup';
 import chai, {expect} from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 
@@ -36,19 +36,20 @@ describe('Apk-signing', function () {
     const apkCopy = path.resolve(tmpDir, path.basename(apiDemosPath));
     await fs.copyFile(apiDemosPath, apkCopy);
     await unsignApk(apkCopy);
-    expect(await adb.checkApkCert(apkCopy)).to.be.false;
+    expect(await adb.checkApkCert(apkCopy, APIDEMOS_PKG)).to.be.false;
   });
   it('checkApkCert should return true for signed apk', async function () {
     // ApiDemos APK is signed but not with the default Appium certificate
     // So we check with requireDefaultCert: false to verify it's signed
-    expect(await adb.checkApkCert(apiDemosPath, {requireDefaultCert: false})).to.be.true;
+    expect(await adb.checkApkCert(apiDemosPath, APIDEMOS_PKG, {requireDefaultCert: false})).to.be
+      .true;
   });
   it('signWithDefaultCert should sign apk', async function () {
     const apkCopy = path.resolve(tmpDir, path.basename(apiDemosPath));
     await fs.copyFile(apiDemosPath, apkCopy);
     await unsignApk(apkCopy);
     await adb.signWithDefaultCert(apkCopy);
-    expect(await adb.checkApkCert(apkCopy)).to.be.true;
+    expect(await adb.checkApkCert(apkCopy, APIDEMOS_PKG)).to.be.true;
   });
   it('signWithCustomCert should sign apk with custom certificate', async function () {
     const customAdb = await ADB.createADB();
@@ -61,6 +62,6 @@ describe('Apk-signing', function () {
     customAdb.keystorePassword = 'android';
     customAdb.keyPassword = 'android';
     await customAdb.signWithCustomCert(apkCopy);
-    expect(await customAdb.checkApkCert(apkCopy)).to.be.true;
+    expect(await customAdb.checkApkCert(apkCopy, APIDEMOS_PKG)).to.be.true;
   });
 });