appium-android-driver 15.0.0-beta.2 → 15.0.0

package/lib/commands/context/exports.ts

@@ -3,6 +3,7 @@ import type {StringRecord} from '@appium/types';
 import {Chromedriver} from 'appium-chromedriver';
 import {errors, PROTOCOLS} from 'appium/driver.js';
 
+import type {AndroidDriverConstraints} from '../../constraints.js';
 import type {AndroidDriver} from '../../driver.js';
 import {APP_STATE} from '../app-management.js';
 import {BIDI_EVENT_NAME} from '../bidi/constants.js';
@@ -22,6 +23,41 @@ import {
   shouldDismissChromeWelcome,
 } from './helpers.js';
 
+declare module '../../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    getContexts(...args: Parameters<typeof getContexts>): ReturnType<typeof getContexts>;
+    getCurrentContext(...args: Parameters<typeof getCurrentContext>): ReturnType<typeof getCurrentContext>;
+    defaultContextName(...args: Parameters<typeof defaultContextName>): ReturnType<typeof defaultContextName>;
+    assignContexts(...args: Parameters<typeof assignContexts>): ReturnType<typeof assignContexts>;
+    switchContext(...args: Parameters<typeof switchContext>): ReturnType<typeof switchContext>;
+    defaultWebviewName(...args: Parameters<typeof defaultWebviewName>): ReturnType<typeof defaultWebviewName>;
+    isChromedriverContext(...args: Parameters<typeof isChromedriverContext>): ReturnType<typeof isChromedriverContext>;
+    startChromedriverProxy(
+      ...args: Parameters<typeof startChromedriverProxy>
+    ): ReturnType<typeof startChromedriverProxy>;
+    stopChromedriverProxies(
+      ...args: Parameters<typeof stopChromedriverProxies>
+    ): ReturnType<typeof stopChromedriverProxies>;
+    suspendChromedriverProxy(
+      ...args: Parameters<typeof suspendChromedriverProxy>
+    ): ReturnType<typeof suspendChromedriverProxy>;
+    startChromeSession(...args: Parameters<typeof startChromeSession>): ReturnType<typeof startChromeSession>;
+    onChromedriverStop(...args: Parameters<typeof onChromedriverStop>): ReturnType<typeof onChromedriverStop>;
+    isWebContext(...args: Parameters<typeof isWebContext>): ReturnType<typeof isWebContext>;
+    mobileGetContexts(...args: Parameters<typeof mobileGetContexts>): ReturnType<typeof mobileGetContexts>;
+    mobileGetChromeCapabilities(
+      ...args: Parameters<typeof mobileGetChromeCapabilities>
+    ): ReturnType<typeof mobileGetChromeCapabilities>;
+    setContext(name?: string): Promise<void>;
+    setWindow(...args: Parameters<typeof setWindow>): ReturnType<typeof setWindow>;
+    getWindowHandle(...args: Parameters<typeof getWindowHandle>): ReturnType<typeof getWindowHandle>;
+    getWindowHandles(...args: Parameters<typeof getWindowHandles>): ReturnType<typeof getWindowHandles>;
+    notifyBiDiContextChange(
+      ...args: Parameters<typeof notifyBiDiContextChange>
+    ): ReturnType<typeof notifyBiDiContextChange>;
+  }
+}
+
 // https://github.com/appium/appium/issues/20710
 const DEFAULT_NATIVE_WINDOW_HANDLE = '1';
 
@@ -66,11 +102,15 @@ export async function setContext(this: AndroidDriver, name?: string | null): Pro
     return;
   }
 
-  const webviewsMapping = await getWebViewsMapping.bind(this)(this.opts);
-  const contexts = this.assignContexts(webviewsMapping);
-  // if the context we want doesn't exist, fail
-  if (!contexts?.includes(newContext)) {
-    throw new errors.NoSuchContextError();
+  let webviewsMapping: WebviewsMapping[] = [];
+  // the native context always exists, so do not wait for the webview scan to switch to it
+  if (newContext !== NATIVE_WIN) {
+    webviewsMapping = await getWebViewsMapping.bind(this)(this.opts);
+    const contexts = this.assignContexts(webviewsMapping);
+    // if the context we want doesn't exist, fail
+    if (!contexts?.includes(newContext)) {
+      throw new errors.NoSuchContextError();
+    }
   }
 
   await this.switchContext(newContext, webviewsMapping);
@@ -429,7 +469,7 @@ export async function startChromeSession(this: AndroidDriver): Promise<void> {
   } else {
     opts.chromeAndroidActivity = this.opts.appActivity;
   }
-  const chromedriver = await setupNewChromedriver.bind(this)(opts, this.adb.curDeviceId as string);
+  const chromedriver = await setupNewChromedriver.bind(this)(opts, this.adb.curDeviceId as string, CHROMIUM_WIN);
   this.chromedriver = chromedriver;
   chromedriver.on(Chromedriver.EVENT_CHANGED, async (msg) => {
     if (msg.state === Chromedriver.STATE_STOPPED) {

package/lib/commands/device/common.ts

@@ -5,6 +5,7 @@ import {retryInterval} from 'asyncbox';
 import {SETTINGS_HELPER_ID} from 'io.appium.settings';
 import * as semver from 'semver';
 
+import type {AndroidDriverConstraints} from '../../constraints.js';
 import type {AndroidDriver} from '../../driver.js';
 import {GET_SERVER_LOGS_FEATURE, nativeLogEntryToSeleniumEntry} from '../../utils.js';
 import {setMockLocationApp} from '../geolocation.js';
@@ -13,6 +14,15 @@ import {adjustTimeZone} from '../time.js';
 import type {ADBDeviceInfo, ADBLaunchInfo} from '../types.js';
 import {createBaseADB, prepareEmulator, pushSettingsApp} from './utils.js';
 
+declare module '../../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    getDeviceInfoFromCaps(...args: Parameters<typeof getDeviceInfoFromCaps>): ReturnType<typeof getDeviceInfoFromCaps>;
+    createADB(...args: Parameters<typeof createADB>): ReturnType<typeof createADB>;
+    getLaunchInfo(...args: Parameters<typeof getLaunchInfo>): ReturnType<typeof getLaunchInfo>;
+    initDevice(...args: Parameters<typeof initDevice>): ReturnType<typeof initDevice>;
+  }
+}
+
 /**
  * Gets device information from capabilities, including UDID and emulator port.
  *
@@ -48,7 +58,7 @@ export async function getDeviceInfoFromCaps(this: AndroidDriver): Promise<ADBDev
 
       // a platform version was given. lets try to find a device with the same os
       const platformVersion = semver.coerce(this.opts.platformVersion) || this.opts.platformVersion;
-      this.log.info(`Looking for a device with Android '${platformVersion}'`);
+      this.log.info(`Looking for a device with Android '${String(platformVersion)}'`);
 
       // in case we fail to find something, give the user a useful log that has
       // the device udids and os versions so they know what's available

package/lib/commands/device/emulator-actions.ts

@@ -1,10 +1,33 @@
 import {util} from '@appium/support';
 import {errors} from 'appium/driver.js';
 
+import type {AndroidDriverConstraints} from '../../constraints.js';
 import type {AndroidDriver} from '../../driver.js';
 import type {GsmAction, GsmSignalStrength, GsmVoiceState, PowerACState, NetworkSpeed} from '../types.js';
 import {requireEmulator} from './utils.js';
 
+declare module '../../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    fingerprint(...args: Parameters<typeof fingerprint>): ReturnType<typeof fingerprint>;
+    mobileFingerprint(...args: Parameters<typeof mobileFingerprint>): ReturnType<typeof mobileFingerprint>;
+    sendSMS(...args: Parameters<typeof sendSMS>): ReturnType<typeof sendSMS>;
+    mobileSendSms(...args: Parameters<typeof mobileSendSms>): ReturnType<typeof mobileSendSms>;
+    gsmCall(...args: Parameters<typeof gsmCall>): ReturnType<typeof gsmCall>;
+    mobileGsmCall(...args: Parameters<typeof mobileGsmCall>): ReturnType<typeof mobileGsmCall>;
+    gsmSignal(...args: Parameters<typeof gsmSignal>): ReturnType<typeof gsmSignal>;
+    mobileGsmSignal(...args: Parameters<typeof mobileGsmSignal>): ReturnType<typeof mobileGsmSignal>;
+    gsmVoice(...args: Parameters<typeof gsmVoice>): ReturnType<typeof gsmVoice>;
+    mobileGsmVoice(...args: Parameters<typeof mobileGsmVoice>): ReturnType<typeof mobileGsmVoice>;
+    powerAC(...args: Parameters<typeof powerAC>): ReturnType<typeof powerAC>;
+    mobilePowerAc(...args: Parameters<typeof mobilePowerAc>): ReturnType<typeof mobilePowerAc>;
+    powerCapacity(...args: Parameters<typeof powerCapacity>): ReturnType<typeof powerCapacity>;
+    mobilePowerCapacity(...args: Parameters<typeof mobilePowerCapacity>): ReturnType<typeof mobilePowerCapacity>;
+    networkSpeed(...args: Parameters<typeof networkSpeed>): ReturnType<typeof networkSpeed>;
+    mobileNetworkSpeed(...args: Parameters<typeof mobileNetworkSpeed>): ReturnType<typeof mobileNetworkSpeed>;
+    sensorSet(...args: Parameters<typeof sensorSet>): ReturnType<typeof sensorSet>;
+  }
+}
+
 /**
  * @deprecated Use mobile: extension
  */

package/lib/commands/device/emulator-console.ts

@@ -1,7 +1,16 @@
 import {errors} from 'appium/driver.js';
 
+import type {AndroidDriverConstraints} from '../../constraints.js';
 import type {AndroidDriver} from '../../driver.js';
 
+declare module '../../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    mobileExecEmuConsoleCommand(
+      ...args: Parameters<typeof mobileExecEmuConsoleCommand>
+    ): ReturnType<typeof mobileExecEmuConsoleCommand>;
+  }
+}
+
 const EMU_CONSOLE_FEATURE = 'emulator_console';
 
 /**

package/lib/commands/device/utils.ts

@@ -34,7 +34,7 @@ export function ensureNetworkSpeed(this: AndroidDriver, networkSpeed: string): s
   }
   this.log.warn(
     `Wrong network speed param '${networkSpeed}', using default: ${this.adb.NETWORK_SPEED.FULL}. ` +
-      `Supported values: ${Object.values(this.adb.NETWORK_SPEED)}`,
+      `Supported values: ${Object.values(this.adb.NETWORK_SPEED).join(', ')}`,
   );
   return this.adb.NETWORK_SPEED.FULL;
 }
@@ -50,8 +50,8 @@ export function prepareAvdArgs(this: AndroidDriver): string[] {
   if (avdArgs) {
     if (Array.isArray(avdArgs)) {
       result.push(...avdArgs);
-    } else {
-      result.push(...util.shellParse(`${avdArgs}`).filter((entry): entry is string => typeof entry === 'string'));
+    } else if (typeof avdArgs === 'string') {
+      result.push(...util.shellParse(avdArgs).filter((entry): entry is string => typeof entry === 'string'));
     }
   }
   if (networkSpeed) {

package/lib/commands/deviceidle.ts

@@ -1,7 +1,14 @@
 import {errors} from 'appium/driver.js';
 
+import type {AndroidDriverConstraints} from '../constraints.js';
 import type {AndroidDriver} from '../driver.js';
 
+declare module '../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    mobileDeviceidle(...args: Parameters<typeof mobileDeviceidle>): ReturnType<typeof mobileDeviceidle>;
+  }
+}
+
 const SUPPORTED_ACTIONS = ['whitelistAdd', 'whitelistRemove'] as const;
 
 /**
@@ -36,7 +43,7 @@ export async function mobileDeviceidle(
       break;
     default:
       throw new errors.InvalidArgumentError(
-        `action must be one of ${JSON.stringify(SUPPORTED_ACTIONS)}. Got '${action}' instead`,
+        `action must be one of ${JSON.stringify(SUPPORTED_ACTIONS)}. Got '${String(action)}' instead`,
       );
   }
   await this.adb.shellChunks(argsGenerator, packagesArr);

package/lib/commands/element.ts

@@ -1,3 +1,24 @@
+import type {AndroidDriverConstraints} from '../constraints.js';
+
+declare module '../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    getAttribute(...args: Parameters<typeof getAttribute>): ReturnType<typeof getAttribute>;
+    getName(...args: Parameters<typeof getName>): ReturnType<typeof getName>;
+    elementDisplayed(...args: Parameters<typeof elementDisplayed>): ReturnType<typeof elementDisplayed>;
+    elementEnabled(...args: Parameters<typeof elementEnabled>): ReturnType<typeof elementEnabled>;
+    elementSelected(...args: Parameters<typeof elementSelected>): ReturnType<typeof elementSelected>;
+    setElementValue(...args: Parameters<typeof setElementValue>): ReturnType<typeof setElementValue>;
+    doSetElementValue(...args: Parameters<typeof doSetElementValue>): ReturnType<typeof doSetElementValue>;
+    replaceValue(...args: Parameters<typeof replaceValue>): ReturnType<typeof replaceValue>;
+    setValueImmediate(...args: Parameters<typeof setValueImmediate>): ReturnType<typeof setValueImmediate>;
+    setValue(...args: Parameters<typeof setValue>): ReturnType<typeof setValue>;
+    click(...args: Parameters<typeof click>): ReturnType<typeof click>;
+    getLocationInView(...args: Parameters<typeof getLocationInView>): ReturnType<typeof getLocationInView>;
+    getText(...args: Parameters<typeof getText>): ReturnType<typeof getText>;
+    getLocation(...args: Parameters<typeof getLocation>): ReturnType<typeof getLocation>;
+    getSize(...args: Parameters<typeof getSize>): ReturnType<typeof getSize>;
+  }
+}
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
 import type {Position, Size} from '@appium/types';

package/lib/commands/execute.ts

@@ -3,8 +3,15 @@ import type {StringRecord, Element} from '@appium/types';
 import type {Chromedriver} from 'appium-chromedriver';
 import {errors, PROTOCOLS} from 'appium/driver.js';
 
+import type {AndroidDriverConstraints} from '../constraints.js';
 import type {AndroidDriver} from '../driver.js';
 
+declare module '../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    execute(...args: Parameters<typeof execute>): ReturnType<typeof execute>;
+  }
+}
+
 const EXECUTE_SCRIPT_PREFIX = 'mobile:';
 
 type ExecuteMethodArgs = readonly any[] | readonly [StringRecord] | Readonly<StringRecord>;

package/lib/commands/file-actions.ts

@@ -4,8 +4,18 @@ import {fs, util, zip, tempDir} from '@appium/support';
 import type {ADB} from 'appium-adb';
 import {errors} from 'appium/driver.js';
 
+import type {AndroidDriverConstraints} from '../constraints.js';
 import type {AndroidDriver} from '../driver.js';
 
+declare module '../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    pullFile(...args: Parameters<typeof pullFile>): ReturnType<typeof pullFile>;
+    pullFolder(...args: Parameters<typeof pullFolder>): ReturnType<typeof pullFolder>;
+    pushFile(...args: Parameters<typeof pushFile>): ReturnType<typeof pushFile>;
+    mobileDeleteFile(...args: Parameters<typeof mobileDeleteFile>): ReturnType<typeof mobileDeleteFile>;
+  }
+}
+
 const CONTAINER_PATH_MARKER = '@';
 const CONTAINER_PATH_PATTERN = new RegExp(`^${CONTAINER_PATH_MARKER}([^/]+)/(.+)`, 's');
 const ANDROID_MEDIA_RESCAN_INTENT = 'android.intent.action.MEDIA_SCANNER_SCAN_FILE';

package/lib/commands/find.ts

@@ -2,9 +2,18 @@ import {util} from '@appium/support';
 import type {Element} from '@appium/types';
 import {errors, isErrorType} from 'appium/driver.js';
 
+import type {AndroidDriverConstraints} from '../constraints.js';
 import type {AndroidDriver} from '../driver.js';
 import type {FindElementOpts} from './types.js';
 
+declare module '../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    findElOrEls(strategy: string, selector: string, mult: true, context?: string): Promise<Element[]>;
+    findElOrEls(strategy: string, selector: string, mult: false, context?: string): Promise<Element>;
+    doFindElementOrEls(...args: Parameters<typeof doFindElementOrEls>): ReturnType<typeof doFindElementOrEls>;
+  }
+}
+
 /**
  * @param strategy The element location strategy to use (e.g., 'id', 'xpath', 'class name').
  * @param selector The selector value to search for.

package/lib/commands/geolocation.ts

@@ -4,10 +4,30 @@ import {fs, tempDir} from '@appium/support';
 import {asyncmap} from 'asyncbox';
 import {SETTINGS_HELPER_ID} from 'io.appium.settings';
 
+import type {AndroidDriverConstraints} from '../constraints.js';
 import type {AndroidDriver} from '../driver.js';
 import {getThirdPartyPackages} from './app-management.js';
 import type {GeoLocation} from './types.js';
 
+declare module '../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    setGeoLocation(...args: Parameters<typeof setGeoLocation>): ReturnType<typeof setGeoLocation>;
+    getGeoLocation(...args: Parameters<typeof getGeoLocation>): ReturnType<typeof getGeoLocation>;
+    mobileRefreshGpsCache(...args: Parameters<typeof mobileRefreshGpsCache>): ReturnType<typeof mobileRefreshGpsCache>;
+    toggleLocationServices(
+      ...args: Parameters<typeof toggleLocationServices>
+    ): ReturnType<typeof toggleLocationServices>;
+    isLocationServicesEnabled(
+      ...args: Parameters<typeof isLocationServicesEnabled>
+    ): ReturnType<typeof isLocationServicesEnabled>;
+    mobileGetGeolocation(...args: Parameters<typeof mobileGetGeolocation>): ReturnType<typeof mobileGetGeolocation>;
+    mobileSetGeolocation(...args: Parameters<typeof mobileSetGeolocation>): ReturnType<typeof mobileSetGeolocation>;
+    mobileResetGeolocation(
+      ...args: Parameters<typeof mobileResetGeolocation>
+    ): ReturnType<typeof mobileResetGeolocation>;
+  }
+}
+
 // The value close to zero, but not zero, is needed
 // to trick JSON generation and send a float value instead of an integer,
 // This allows strictly-typed clients, like Java, to properly
@@ -149,7 +169,7 @@ export async function mobileResetGeolocation(this: AndroidDriver): Promise<void>
   if (this.isEmulator()) {
     throw new Error('Geolocation reset does not work on emulators');
   }
-  await resetMockLocation.bind(this);
+  await resetMockLocation.bind(this)();
 }
 
 // #region Internal helpers
@@ -213,7 +233,7 @@ async function resetMockLocation(this: AndroidDriver): Promise<void> {
       return;
     }
 
-    this.log.debug(`Resetting mock_location permission for the following apps: ${resultPkgs}`);
+    this.log.debug(`Resetting mock_location permission for the following apps: ${resultPkgs.join(', ')}`);
     await asyncmap(resultPkgs, async (pkgId) => {
       try {
         await this.adb.shell(['appops', 'set', pkgId, 'android:mock_location', 'deny']);

package/lib/commands/gestures.ts

@@ -1,8 +1,15 @@
 import type {StringRecord} from '@appium/types';
 import {errors} from 'appium/driver.js';
 
+import type {AndroidDriverConstraints} from '../constraints.js';
 import type {AndroidDriver} from '../driver.js';
 
+declare module '../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    performActions(...args: Parameters<typeof performActions>): ReturnType<typeof performActions>;
+  }
+}
+
 /**
  * Performs a series of actions (gestures) on the device.
  *

package/lib/commands/image-injection.ts

@@ -4,8 +4,17 @@ import path from 'node:path';
 import {fs, tempDir} from '@appium/support';
 import {errors} from 'appium/driver.js';
 
+import type {AndroidDriverConstraints} from '../constraints.js';
 import type {AndroidDriver} from '../driver.js';
 
+declare module '../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    mobileInjectEmulatorCameraImage(
+      ...args: Parameters<typeof mobileInjectEmulatorCameraImage>
+    ): ReturnType<typeof mobileInjectEmulatorCameraImage>;
+  }
+}
+
 const EMULATOR_RESOURCES_ROOT = ['emulator', 'resources'];
 const CONFIG_NAME = 'Toren1BD.posters';
 const DEFAULT_CONFIG_PAYLOAD_PREFIX = `poster wall

package/lib/commands/ime.ts

@@ -1,8 +1,20 @@
 import {errors} from 'appium/driver.js';
 
+import type {AndroidDriverConstraints} from '../constraints.js';
 import type {AndroidDriver} from '../driver.js';
 import {SET_STYLUS_HANDWRITING_FEATURE} from '../utils.js';
 
+declare module '../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    isIMEActivated(...args: Parameters<typeof isIMEActivated>): ReturnType<typeof isIMEActivated>;
+    availableIMEEngines(...args: Parameters<typeof availableIMEEngines>): ReturnType<typeof availableIMEEngines>;
+    getActiveIMEEngine(...args: Parameters<typeof getActiveIMEEngine>): ReturnType<typeof getActiveIMEEngine>;
+    activateIMEEngine(...args: Parameters<typeof activateIMEEngine>): ReturnType<typeof activateIMEEngine>;
+    deactivateIMEEngine(...args: Parameters<typeof deactivateIMEEngine>): ReturnType<typeof deactivateIMEEngine>;
+    setStylusHandwriting(...args: Parameters<typeof setStylusHandwriting>): ReturnType<typeof setStylusHandwriting>;
+  }
+}
+
 /**
  * Checks if an IME (Input Method Editor) is activated.
  *

package/lib/commands/intent.ts

@@ -1,9 +1,30 @@
 import {util} from '@appium/support';
 import {errors} from 'appium/driver.js';
 
+import type {AndroidDriverConstraints} from '../constraints.js';
 import type {AndroidDriver} from '../driver.js';
 import type {IntentOpts} from './types.js';
 
+declare module '../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    startActivity(
+      appPackage: string,
+      appActivity: string,
+      appWaitPackage?: string,
+      appWaitActivity?: string,
+      intentAction?: string,
+      intentCategory?: string,
+      intentFlags?: string,
+      optionalIntentArguments?: string,
+      dontStopAppOnReset?: boolean,
+    ): Promise<void>;
+    mobileStartActivity(...args: Parameters<typeof mobileStartActivity>): ReturnType<typeof mobileStartActivity>;
+    mobileBroadcast(...args: Parameters<typeof mobileBroadcast>): ReturnType<typeof mobileBroadcast>;
+    mobileStartService(...args: Parameters<typeof mobileStartService>): ReturnType<typeof mobileStartService>;
+    mobileStopService(...args: Parameters<typeof mobileStopService>): ReturnType<typeof mobileStopService>;
+  }
+}
+
 const NO_VALUE_ARG_TYPE = 'sn';
 const SUPPORTED_EXTRA_TYPES = [
   's',
@@ -354,9 +375,6 @@ export async function mobileStopService(
 function parseIntentSpec(opts: IntentOpts = {}): string[] {
   const {intent, action, uri, mimeType, identifier, categories, component, extras, flags} = opts;
   const resultArgs: string[] = [];
-  if (intent) {
-    resultArgs.push(intent);
-  }
   if (action) {
     resultArgs.push('-a', action);
   }
@@ -388,7 +406,7 @@ function parseIntentSpec(opts: IntentOpts = {}): string[] {
     }
     for (const item of extras) {
       if (!Array.isArray(item)) {
-        throw new errors.InvalidArgumentError(`Extra argument '${item}' must be an array`);
+        throw new errors.InvalidArgumentError(`Extra argument '${String(item)}' must be an array`);
       }
       const [type, key, value] = item;
       if (!SUPPORTED_EXTRA_TYPES.includes(type as any)) {
@@ -416,6 +434,9 @@ function parseIntentSpec(opts: IntentOpts = {}): string[] {
   if (flags) {
     resultArgs.push('-f', flags);
   }
+  if (intent) {
+    resultArgs.push(intent);
+  }
   return resultArgs;
 }
 

package/lib/commands/keyboard.ts

@@ -1,9 +1,24 @@
 import {errors} from 'appium/driver.js';
 import {UNICODE_IME, EMPTY_IME} from 'io.appium.settings';
 
+import type {AndroidDriverConstraints} from '../constraints.js';
 import type {AndroidDriver} from '../driver.js';
 import type {SendKeysOpts} from './types.js';
 
+declare module '../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    hideKeyboard(...args: Parameters<typeof hideKeyboard>): ReturnType<typeof hideKeyboard>;
+    isKeyboardShown(...args: Parameters<typeof isKeyboardShown>): ReturnType<typeof isKeyboardShown>;
+    keys(...args: Parameters<typeof keys>): ReturnType<typeof keys>;
+    doSendKeys(...args: Parameters<typeof doSendKeys>): ReturnType<typeof doSendKeys>;
+    pressKeyCode(...args: Parameters<typeof pressKeyCode>): ReturnType<typeof pressKeyCode>;
+    longPressKeyCode(...args: Parameters<typeof longPressKeyCode>): ReturnType<typeof longPressKeyCode>;
+    mobilePerformEditorAction(
+      ...args: Parameters<typeof mobilePerformEditorAction>
+    ): ReturnType<typeof mobilePerformEditorAction>;
+  }
+}
+
 /**
  * Hides the on-screen keyboard.
  *

package/lib/commands/legacy.ts

@@ -1,7 +1,16 @@
 import {errors} from 'appium/driver.js';
 
+import type {AndroidDriverConstraints} from '../constraints.js';
 import type {AndroidDriver} from '../driver.js';
 
+declare module '../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    reset(...args: Parameters<typeof reset>): ReturnType<typeof reset>;
+    closeApp(...args: Parameters<typeof closeApp>): ReturnType<typeof closeApp>;
+    launchApp(...args: Parameters<typeof launchApp>): ReturnType<typeof launchApp>;
+  }
+}
+
 const ISSUE_URL = 'https://github.com/appium/appium/issues/15807';
 
 /**

package/lib/commands/lock/exports.ts

@@ -1,5 +1,6 @@
 import {sleep} from 'asyncbox';
 
+import type {AndroidDriverConstraints} from '../../constraints.js';
 import type {AndroidDriver, AndroidDriverCaps} from '../../driver.js';
 import type {UnlockType} from '../types.js';
 import {
@@ -19,6 +20,15 @@ import {
   verifyUnlock,
 } from './helpers.js';
 
+declare module '../../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    lock(...args: Parameters<typeof lock>): ReturnType<typeof lock>;
+    unlock(...args: Parameters<typeof unlock>): ReturnType<typeof unlock>;
+    mobileUnlock(...args: Parameters<typeof mobileUnlock>): ReturnType<typeof mobileUnlock>;
+    isLocked(...args: Parameters<typeof isLocked>): ReturnType<typeof isLocked>;
+  }
+}
+
 /**
  * Locks the device and optionally unlocks it after a specified number of seconds.
  *

package/lib/commands/lock/helpers.ts

@@ -70,7 +70,7 @@ export function validateUnlockCapabilities<T extends AndroidDriverCaps>(caps: T)
     }
   } else {
     throw new Error(
-      `Invalid unlock type '${unlockType}'. Only the following unlock types are supported: ${UNLOCK_TYPES}`,
+      `Invalid unlock type '${unlockType}'. Only the following unlock types are supported: ${UNLOCK_TYPES.join(', ')}`,
     );
   }
   return caps;

package/lib/commands/log.ts

@@ -4,16 +4,31 @@ import os from 'node:os';
 import {util} from '@appium/support';
 import type {AppiumServer, WSServer} from '@appium/types';
 import type {ADB} from 'appium-adb';
-import type {Chromedriver} from 'appium-chromedriver';
-import {DEFAULT_WS_PATHNAME_PREFIX, BaseDriver} from 'appium/driver.js';
+import {DEFAULT_WS_PATHNAME_PREFIX} from 'appium/driver.js';
 import {WebSocket, WebSocketServer} from 'ws';
 
+import type {AndroidDriverConstraints} from '../constraints.js';
 import type {AndroidDriver} from '../driver.js';
 import {GET_SERVER_LOGS_FEATURE, toLogRecord, nativeLogEntryToSeleniumEntry, type LogEntry} from '../utils.js';
 import {BIDI_EVENT_NAME} from './bidi/constants.js';
 import {makeLogEntryAddedEvent} from './bidi/models.js';
 import {NATIVE_WIN} from './context/helpers.js';
 
+declare module '../driver.js' {
+  interface AndroidDriver<C extends AndroidDriverConstraints> {
+    mobileStartLogsBroadcast(
+      ...args: Parameters<typeof mobileStartLogsBroadcast>
+    ): ReturnType<typeof mobileStartLogsBroadcast>;
+    mobileStopLogsBroadcast(
+      ...args: Parameters<typeof mobileStopLogsBroadcast>
+    ): ReturnType<typeof mobileStopLogsBroadcast>;
+    assignBiDiLogListener<EE extends EventEmitter>(
+      logEmitter: EE,
+      properties: BiDiListenerProperties,
+    ): [EE, LogListener];
+  }
+}
+
 export const supportedLogTypes = {
   logcat: {
     description: 'Logs for Android applications on real device and emulators via ADB',
@@ -67,7 +82,7 @@ export async function mobileStartLogsBroadcast(this: AndroidDriver): Promise<voi
       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}`);
+      this.log.debug(`Established a new logcat listener web socket connection from ${String(remoteIp)}`);
     } else {
       this.log.debug('Established a new logcat listener web socket connection');
     }
@@ -81,8 +96,8 @@ export async function mobileStartLogsBroadcast(this: AndroidDriver): Promise<voi
           }
         }
       };
+      this.adb.setLogcatListener(this._logcatWebsocketListener);
     }
-    this.adb.setLogcatListener(this._logcatWebsocketListener);
 
     ws.on('close', (code, reason) => {
       connectedSockets.delete(ws);
@@ -94,7 +109,7 @@ export async function mobileStartLogsBroadcast(this: AndroidDriver): Promise<voi
       }
 
       let closeMsg = 'Logcat listener web socket is closed.';
-      if (!util.isEmpty(code)) {
+      if (code) {
         closeMsg += ` Code: ${code}.`;
       }
       if (!util.isEmpty(reason)) {
@@ -125,21 +140,6 @@ export async function mobileStopLogsBroadcast(this: AndroidDriver): Promise<void
   await server.removeWebSocketHandler(pathname);
 }
 
-/**
- * Gets the list of available log types.
- *
- * @returns Promise that resolves to an array of log type names.
- */
-export async function getLogTypes(this: AndroidDriver): Promise<string[]> {
-  // XXX why doesn't `super` work here?
-  const nativeLogTypes = await BaseDriver.prototype.getLogTypes.call(this);
-  if (this.isWebContext()) {
-    const webLogTypes = (await (this.chromedriver as Chromedriver).jwproxy.command('/log/types', 'GET')) as string[];
-    return [...nativeLogTypes, ...webLogTypes];
-  }
-  return nativeLogTypes;
-}
-
 /**
  * Assigns a BiDi log listener to an event emitter.
  *
@@ -164,21 +164,6 @@ export function assignBiDiLogListener<EE extends EventEmitter>(
   return [logEmitter, listener];
 }
 
-/**
- * Gets logs of a specific type.
- *
- * @param logType The type of logs to retrieve.
- * @returns Promise that resolves to the logs for the specified type.
- */
-export async function getLog(this: AndroidDriver, logType: string): Promise<any> {
-  if (this.isWebContext() && !Object.keys(this.supportedLogTypes).includes(logType)) {
-    return await (this.chromedriver as Chromedriver).jwproxy.command('/log', 'POST', {
-      type: logType,
-    });
-  }
-  return await BaseDriver.prototype.getLog.call(this, logType);
-}
-
 // #region Internal helpers
 
 /**