webdriverio 9.26.0 → 9.26.1

package/build/commands/mobile/closeApp.d.ts

@@ -1,17 +1,35 @@
 /**
  *
- * Close the currently open app on the device.
+ * Close a specific app or the currently active app on the device.
  *
  * > **Note:** Falls back to the deprecated Appium 2 protocol endpoint if the driver does not support the `mobile:` execute method.
  *
+ * If no `bundleId` (iOS) or `appId` (Android) is provided, the command will automatically detect and close the currently active app.
+ *
  * <example>
     :closeApp.js
-    it('should close the current app', async () => {
+    it('should close the currently active app', async () => {
+        // Automatically close the currently active app
         await browser.closeApp()
     })
+    it('should close a specific iOS app by bundleId', async () => {
+        // iOS: close a specific app using its bundle ID
+        await browser.closeApp({ bundleId: 'com.example.myapp' })
+    })
+    it('should close a specific Android app by appId', async () => {
+        // Android: close a specific app using its package name
+        await browser.closeApp({ appId: 'com.example.myapp' })
+    })
  * </example>
  *
+ * @param {object}  [options]          Options for closing the app (optional)
+ * @param {string}  [options.bundleId] The bundle ID of the iOS app to close. If not provided, the currently active app is closed. <br /><strong>iOS-ONLY</strong>
+ * @param {string}  [options.appId]    The package name of the Android app to close. If not provided, the currently active app is closed. <br /><strong>ANDROID-ONLY</strong>
+ *
  * @support ["ios","android"]
  */
-export declare function closeApp(this: WebdriverIO.Browser): Promise<unknown>;
+export declare function closeApp(this: WebdriverIO.Browser, options?: {
+    bundleId?: string;
+    appId?: string;
+}): Promise<unknown>;
 //# sourceMappingURL=closeApp.d.ts.map

package/build/commands/mobile/closeApp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"closeApp.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/closeApp.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,QAAQ,CAC1B,IAAI,EAAE,WAAW,CAAC,OAAO,oBAkB5B"}
+{"version":3,"file":"closeApp.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/closeApp.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAsB,QAAQ,CAC1B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,OAAO,CAAC,EAAE;IACN,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;CACjB,oBA6BJ"}

package/build/commands/mobile/deepLink.d.ts

@@ -14,12 +14,17 @@
         // Or if you want to have it "cross-platform" you can use it like this
         await browser.deepLink('wdio://drag', browser.isIOS ? 'org.reactjs.native.example.wdiodemoapp' : 'com.wdiodemoapp');
     })
+    it('should open a deep link without waiting for the app to launch (Android)', async () => {
+        // Android-only: do not wait for the app to launch after opening the deep link
+        await browser.deepLink('wdio://drag', 'com.wdiodemoapp', false)
+    })
  * </example>
  *
- * @param {string}  link            The deep link URL that should be opened in the mobile app. It should be a valid deep link URL (e.g. `myapp://path`). If it's a universal deep link, which can be used for iOS, use the `browser.url("your-url")`-method.
- * @param {string}  appIdentifier   The value of the `package` (Android) or `bundleId` (iOS) of the app that the deep link should open.
+ * @param {string}   link             The deep link URL that should be opened in the mobile app. It should be a valid deep link URL (e.g. `myapp://path`). If it's a universal deep link, which can be used for iOS, use the `browser.url("your-url")`-method.
+ * @param {string}   appIdentifier    The value of the `package` (Android) or `bundleId` (iOS) of the app that the deep link should open.
+ * @param {boolean}  [waitForLaunch]  Whether to wait for the app to launch after opening the deep link. Default is `true`. <br /><strong>ANDROID-ONLY</strong>
  *
  * @support ["ios","android"]
  */
-export declare function deepLink(this: WebdriverIO.Browser, link: string, appIdentifier: string): Promise<unknown>;
+export declare function deepLink(this: WebdriverIO.Browser, link: string, appIdentifier: string, waitForLaunch?: boolean): Promise<unknown>;
 //# sourceMappingURL=deepLink.d.ts.map

package/build/commands/mobile/deepLink.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deepLink.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/deepLink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,QAAQ,CAC1B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,oBAuBxB"}
+{"version":3,"file":"deepLink.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/deepLink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,QAAQ,CAC1B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,OAAO,oBA6B1B"}

package/build/commands/mobile/gsmSignal.d.ts

@@ -1,20 +1,22 @@
 /**
  *
- * Set the GSM signal strength on the Android emulator. Value must be in range [0, 4] where 0 is
- * no signal and 4 is full signal.
+ * Set the GSM signal strength on the Android emulator.
  *
  * > **Note:** Falls back to the deprecated Appium 2 protocol endpoint if the driver does not support the `mobile:` execute method.
  *
  * <example>
     :gsmSignal.js
     it('should set GSM signal to full strength', async () => {
-        await browser.gsmSignal('4')
+        await browser.gsmSignal(4)
+    })
+    it('should set GSM signal to no signal', async () => {
+        await browser.gsmSignal(0)
     })
  * </example>
  *
- * @param {string}  signalStrength  The signal strength to set (0–4, where 0 is none and 4 is full)
+ * @param {number}  signalStrength  The signal strength to set. Accepted values: `0` (no signal), `1` (very poor), `2` (poor), `3` (moderate), `4` (good/full)
  *
  * @support ["android"]
  */
-export declare function gsmSignal(this: WebdriverIO.Browser, signalStrength: string): Promise<unknown>;
+export declare function gsmSignal(this: WebdriverIO.Browser, signalStrength: number): Promise<unknown>;
 //# sourceMappingURL=gsmSignal.d.ts.map

package/build/commands/mobile/gsmSignal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gsmSignal.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/gsmSignal.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,SAAS,CAC3B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,cAAc,EAAE,MAAM,oBAsBzB"}
+{"version":3,"file":"gsmSignal.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/gsmSignal.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,SAAS,CAC3B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,cAAc,EAAE,MAAM,oBAsBzB"}

package/build/commands/mobile/launchApp.d.ts

@@ -1,17 +1,46 @@
 /**
  *
- * Launch the app configured in the current session capabilities.
+ * Launch or activate an app on the device. If no `bundleId` (iOS) or `appId` (Android) is provided,
+ * the command will automatically detect and activate the currently active app.
  *
  * > **Note:** Falls back to the deprecated Appium 2 protocol endpoint if the driver does not support the `mobile:` execute method.
  *
  * <example>
     :launchApp.js
-    it('should launch the app', async () => {
+    it('should launch a specific iOS app', async () => {
+        // iOS: launch a specific app by bundle ID
+        await browser.launchApp({ bundleId: 'com.example.myapp' })
+    })
+    it('should launch an iOS app with arguments and environment', async () => {
+        // iOS: launch an app and pass arguments and environment variables
+        await browser.launchApp({
+            bundleId: 'com.example.myapp',
+            arguments: ['-AppleLanguages', '(en)'],
+            environment: { MY_ENV_VAR: 'value' }
+        })
+    })
+    it('should launch a specific Android app', async () => {
+        // Android: activate/launch a specific app by package name
+        await browser.launchApp({ appId: 'com.example.myapp' })
+    })
+    it('should activate the currently active app', async () => {
+        // Automatically detect and activate the current app
         await browser.launchApp()
     })
  * </example>
  *
+ * @param {object}            [options]              Options for launching the app (optional)
+ * @param {string}            [options.bundleId]     The bundle ID of the iOS app to launch. If not provided, the currently active app is used. <br /><strong>iOS-ONLY</strong>
+ * @param {string|string[]}   [options.arguments]    Command line arguments to pass to the app on launch. <br /><strong>iOS-ONLY</strong>
+ * @param {object}            [options.environment]  Environment variables to set when launching the app (key-value pairs). <br /><strong>iOS-ONLY</strong>
+ * @param {string}            [options.appId]        The package name of the Android app to activate. If not provided, the currently active app is used. <br /><strong>ANDROID-ONLY</strong>
+ *
  * @support ["ios","android"]
  */
-export declare function launchApp(this: WebdriverIO.Browser): Promise<unknown>;
+export declare function launchApp(this: WebdriverIO.Browser, options?: {
+    bundleId?: string;
+    arguments?: string | string[];
+    environment?: Record<string, string>;
+    appId?: string;
+}): Promise<unknown>;
 //# sourceMappingURL=launchApp.d.ts.map

package/build/commands/mobile/launchApp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"launchApp.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/launchApp.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,SAAS,CAC3B,IAAI,EAAE,WAAW,CAAC,OAAO,oBAoB5B"}
+{"version":3,"file":"launchApp.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/launchApp.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAsB,SAAS,CAC3B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,OAAO,CAAC,EAAE;IACN,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,KAAK,CAAC,EAAE,MAAM,CAAA;CACjB,oBAsCJ"}

package/build/commands/mobile/sendKeyEvent.d.ts

@@ -12,11 +12,13 @@
     it('should send a key event', async () => {
         // Send the Home key event (keycode '3')
         await browser.sendKeyEvent('3')
+        // Send Shift+A (keycode '29', metastate '1')
+        await browser.sendKeyEvent('29', '1')
     })
  * </example>
  *
- * @param {string}  keycode     The keycode to send (as a string, e.g. '3' for Home)
- * @param {string}  [metastate] Meta state to press the keycode with (e.g. '1' for Shift)
+ * @param {string}  keycode     The keycode to send (as a string, e.g. `'3'` for Home). See [Android KeyEvent](https://developer.android.com/reference/android/view/KeyEvent) for all available keycodes.
+ * @param {string}  [metastate] The meta state to apply during the key press as a string (e.g. `'1'` for Shift). See [Android KeyEvent](https://developer.android.com/reference/android/view/KeyEvent) for all meta state values.
  *
  * @support ["android"]
  */

package/build/commands/mobile/sendKeyEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sendKeyEvent.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/sendKeyEvent.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,YAAY,CAC9B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,oBAqBrB"}
+{"version":3,"file":"sendKeyEvent.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/sendKeyEvent.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,YAAY,CAC9B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,oBAyBrB"}

package/build/commands/mobile/startActivity.d.ts

@@ -1,30 +1,90 @@
+export interface StartActivityOptions {
+    /**
+     * The package name of the app to start.
+     */
+    appPackage: string;
+    /**
+     * The activity name to start.
+     */
+    appActivity: string;
+    /**
+     * The package name to wait for after starting the activity. Passed to the legacy fallback only.
+     * <br /><strong>LEGACY-ONLY</strong>
+     */
+    appWaitPackage?: string;
+    /**
+     * The activity name to wait for after starting the activity. Passed to the legacy fallback only.
+     * <br /><strong>LEGACY-ONLY</strong>
+     */
+    appWaitActivity?: string;
+    /**
+     * The intent action to use to start the activity (maps to `action` in the new driver API).
+     */
+    intentAction?: string;
+    /**
+     * The intent category to use to start the activity (maps to `categories` in the new driver API).
+     */
+    intentCategory?: string;
+    /**
+     * Flags to use when starting the activity (maps to `flags` in the new driver API).
+     */
+    intentFlags?: string;
+    /**
+     * Additional intent arguments. Passed to the legacy fallback only.
+     * <br /><strong>LEGACY-ONLY</strong>
+     */
+    optionalIntentArguments?: string;
+    /**
+     * Whether to stop the app before starting the activity. Passed as `stop` (inverted) to the new driver API.
+     */
+    dontStopAppOnReset?: string;
+}
 /**
  *
  * Start an Android activity by providing package name and activity name.
  *
+ * Supports both the legacy positional argument style and a new object-based style.
+ * When the first argument is an object, the object properties are used. When it is a
+ * string, the call is treated as the old positional API for backward compatibility.
+ *
  * > **Note:** Falls back to the deprecated Appium 2 protocol endpoint if the driver does not support the `mobile:` execute method.
  *
  * <example>
     :startActivity.js
-    it('should start an Android activity', async () => {
-        // Start a specific activity
+    it('should start an Android activity (object API)', async () => {
+        // New object-based API
+        await browser.startActivity({
+            appPackage: 'com.example.app',
+            appActivity: '.MainActivity',
+        })
+        // With optional intent parameters
+        await browser.startActivity({
+            appPackage: 'com.example.app',
+            appActivity: '.MainActivity',
+            intentAction: 'android.intent.action.MAIN',
+            intentCategory: 'android.intent.category.LAUNCHER',
+            intentFlags: '0x10200000',
+        })
+    })
+    it('should start an Android activity (legacy positional API)', async () => {
+        // Legacy positional API (backward compatible)
         await browser.startActivity('com.example.app', '.MainActivity')
-        // Start activity and wait for another to appear
+        // With wait package/activity
         await browser.startActivity('com.example.app', '.SplashActivity', 'com.example.app', '.MainActivity')
     })
  * </example>
  *
- * @param {string}  appPackage                The package name of the app to start
- * @param {string}  appActivity               The activity name to start
- * @param {string}  [appWaitPackage]          The package name to wait for after starting the activity
- * @param {string}  [appWaitActivity]         The activity name to wait for after starting the activity
- * @param {string}  [intentAction]            The intent action to use to start the activity
- * @param {string}  [intentCategory]          The intent category to use to start the activity
- * @param {string}  [intentFlags]             Flags to use when starting the activity
- * @param {string}  [optionalIntentArguments] Additional intent arguments to use when starting the activity
- * @param {string}  [dontStopAppOnReset]      Whether to stop the app before starting the activity
+ * @param {StartActivityOptions|string}  appPackageOrOptions       The package name of the app to start, or an options object.
+ * @param {string}                       [appActivity]             The activity name to start (only used when first arg is a string).
+ * @param {string}                       [appWaitPackage]          The package name to wait for (legacy, only used when first arg is a string). <br /><strong>LEGACY-ONLY</strong>
+ * @param {string}                       [appWaitActivity]         The activity name to wait for (legacy, only used when first arg is a string). <br /><strong>LEGACY-ONLY</strong>
+ * @param {string}                       [intentAction]            The intent action (legacy positional, only used when first arg is a string).
+ * @param {string}                       [intentCategory]          The intent category (legacy positional, only used when first arg is a string).
+ * @param {string}                       [intentFlags]             Flags for the intent (legacy positional, only used when first arg is a string).
+ * @param {string}                       [optionalIntentArguments] Additional intent arguments (legacy, only used when first arg is a string). <br /><strong>LEGACY-ONLY</strong>
+ * @param {string}                       [dontStopAppOnReset]      Whether to stop the app before starting the activity (legacy positional, only used when first arg is a string).
  *
  * @support ["android"]
  */
-export declare function startActivity(this: WebdriverIO.Browser, appPackage: string, appActivity: string, appWaitPackage?: string, appWaitActivity?: string, intentAction?: string, intentCategory?: string, intentFlags?: string, optionalIntentArguments?: string, dontStopAppOnReset?: string): Promise<unknown>;
+export declare function startActivity(this: WebdriverIO.Browser, appPackageOrOptions: StartActivityOptions | string, appActivity?: string, appWaitPackage?: string, appWaitActivity?: string, intentAction?: string, intentCategory?: string, intentFlags?: string, optionalIntentArguments?: string, dontStopAppOnReset?: string): Promise<unknown>;
 //# sourceMappingURL=startActivity.d.ts.map

package/build/commands/mobile/startActivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"startActivity.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/startActivity.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,aAAa,CAC/B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,MAAM,EACvB,eAAe,CAAC,EAAE,MAAM,EACxB,YAAY,CAAC,EAAE,MAAM,EACrB,cAAc,CAAC,EAAE,MAAM,EACvB,WAAW,CAAC,EAAE,MAAM,EACpB,uBAAuB,CAAC,EAAE,MAAM,EAChC,kBAAkB,CAAC,EAAE,MAAM,oBA0C9B"}
+{"version":3,"file":"startActivity.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/startActivity.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,oBAAoB;IACjC;;OAEG;IACH,UAAU,EAAE,MAAM,CAAA;IAClB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,uBAAuB,CAAC,EAAE,MAAM,CAAA;IAChC;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,wBAAsB,aAAa,CAC/B,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,mBAAmB,EAAE,oBAAoB,GAAG,MAAM,EAClD,WAAW,CAAC,EAAE,MAAM,EACpB,cAAc,CAAC,EAAE,MAAM,EACvB,eAAe,CAAC,EAAE,MAAM,EACxB,YAAY,CAAC,EAAE,MAAM,EACrB,cAAc,CAAC,EAAE,MAAM,EACvB,WAAW,CAAC,EAAE,MAAM,EACpB,uBAAuB,CAAC,EAAE,MAAM,EAChC,kBAAkB,CAAC,EAAE,MAAM,oBA8D9B"}

package/build/commands/mobile/touchId.d.ts

@@ -1,6 +1,6 @@
 /**
  *
- * Simulate a Touch ID fingerprint match event on iOS Simulator.
+ * Simulate a Touch ID or Face ID biometric match event on iOS Simulator.
  *
  * > **Note:** Falls back to the deprecated Appium 2 protocol endpoint if the driver does not support the `mobile:` execute method.
  *
@@ -11,17 +11,24 @@
  *
  * <example>
     :touchId.js
-    it('should simulate a fingerprint match', async () => {
-        // Simulate successful fingerprint match
+    it('should simulate a Touch ID fingerprint match', async () => {
+        // Simulate a successful Touch ID match
         await browser.touchId(true)
-        // Simulate failed fingerprint match
+        // Simulate a failed Touch ID match
         await browser.touchId(false)
     })
+    it('should simulate a Face ID match', async () => {
+        // Simulate a successful Face ID match
+        await browser.touchId(true, 'faceId')
+        // Simulate a failed Face ID match
+        await browser.touchId(false, 'faceId')
+    })
  * </example>
  *
- * @param {boolean} match   Whether the fingerprint match should succeed (`true`) or fail (`false`)
+ * @param {boolean} match   Whether the biometric match should succeed (`true`) or fail (`false`)
+ * @param {string}  [type]  The biometric type to simulate. Use `'touchId'` for Touch ID (default) or `'faceId'` for Face ID. <br /><strong>iOS-ONLY</strong>
  *
  * @support ["ios"]
  */
-export declare function touchId(this: WebdriverIO.Browser, match: boolean): Promise<unknown>;
+export declare function touchId(this: WebdriverIO.Browser, match: boolean, type?: 'touchId' | 'faceId'): Promise<unknown>;
 //# sourceMappingURL=touchId.d.ts.map

package/build/commands/mobile/touchId.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"touchId.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/touchId.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,OAAO,CACzB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,KAAK,EAAE,OAAO,oBAsBjB"}
+{"version":3,"file":"touchId.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/touchId.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,OAAO,CACzB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,KAAK,EAAE,OAAO,EACd,IAAI,GAAE,SAAS,GAAG,QAAoB,oBAsBzC"}

package/build/commands/mobile/unlock.d.ts

@@ -7,11 +7,35 @@
  * <example>
     :unlock.js
     it('should unlock the device screen', async () => {
+        // Unlock with no arguments (iOS or Android with default settings)
         await browser.unlock()
     })
+    it('should unlock Android with a PIN', async () => {
+        // Android-only: unlock using locksettings strategy with a PIN
+        await browser.unlock({
+            strategy: 'locksettings',
+            unlockType: 'pin',
+            unlockKey: '1234'
+        })
+    })
+    it('should unlock Android with a custom timeout', async () => {
+        // Android-only: unlock with a custom timeout
+        await browser.unlock({ timeoutMs: 5000 })
+    })
  * </example>
  *
+ * @param {object}  [options]               Unlock options (Android only)
+ * @param {string}  [options.strategy]      The unlock strategy to use. Accepted values: `'locksettings'` (default) or `'uiautomator'`. <br /><strong>ANDROID-ONLY</strong>
+ * @param {number}  [options.timeoutMs]     The timeout in milliseconds to wait for the unlock to complete. Default is `2000`. <br /><strong>ANDROID-ONLY</strong>
+ * @param {string}  [options.unlockKey]     The PIN, password, or pattern to use for unlocking. Required when the device has a PIN/password lock. <br /><strong>ANDROID-ONLY</strong>
+ * @param {string}  [options.unlockType]    The type of lock mechanism on the device (e.g. `'pin'`, `'password'`, `'pattern'`). <br /><strong>ANDROID-ONLY</strong>
+ *
  * @support ["ios","android"]
  */
-export declare function unlock(this: WebdriverIO.Browser): Promise<unknown>;
+export declare function unlock(this: WebdriverIO.Browser, options?: {
+    strategy?: 'locksettings' | 'uiautomator';
+    timeoutMs?: number;
+    unlockKey?: string;
+    unlockType?: string;
+}): Promise<unknown>;
 //# sourceMappingURL=unlock.d.ts.map

package/build/commands/mobile/unlock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unlock.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/unlock.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,MAAM,CACxB,IAAI,EAAE,WAAW,CAAC,OAAO,oBAkB5B"}
+{"version":3,"file":"unlock.d.ts","sourceRoot":"","sources":["../../../src/commands/mobile/unlock.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,MAAM,CACxB,IAAI,EAAE,WAAW,CAAC,OAAO,EACzB,OAAO,CAAC,EAAE;IACN,QAAQ,CAAC,EAAE,cAAc,GAAG,aAAa,CAAA;IACzC,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;CACtB,oBAsBJ"}

package/build/index.js

@@ -6479,7 +6479,7 @@ async function relaunchActiveApp() {
 }
 
 // src/commands/mobile/deepLink.ts
-async function deepLink(link, appIdentifier) {
+async function deepLink(link, appIdentifier, waitForLaunch) {
   const browser = this;
   if (!browser.isMobile) {
     throw new Error("The `deepLink` command is only available for mobile platforms.");
@@ -6492,10 +6492,14 @@ async function deepLink(link, appIdentifier) {
     const identifierValue = browser.isIOS ? "bundleId" : "package";
     throw new Error("When using a deep link URL for ".concat(mobileOS, ", you need to provide the `").concat(identifierValue, "` of the app that the deep link should open."));
   }
-  return browser.execute("mobile:deepLink", {
+  const args = {
     url: link,
     [browser.isIOS ? "bundleId" : "package"]: appIdentifier
-  });
+  };
+  if (!browser.isIOS && waitForLaunch !== void 0) {
+    args.waitForLaunch = waitForLaunch;
+  }
+  return browser.execute("mobile:deepLink", args);
 }
 function isDeepLinkUrl(link) {
   const deepLinkRegex = /^(?!https?:\/\/)[a-zA-Z][\w+\-.]*:\/\//;
@@ -6520,7 +6524,7 @@ async function lock(seconds) {
 }
 
 // src/commands/mobile/touchId.ts
-async function touchId(match) {
+async function touchId(match, type = "touchId") {
   const browser = this;
   if (!browser.isMobile) {
     throw new Error("The `touchId` command is only available for mobile platforms.");
@@ -6529,7 +6533,7 @@ async function touchId(match) {
     throw new Error("The `touchId` command is only available for iOS. For Android, use `fingerPrint` instead.");
   }
   try {
-    return await browser.execute("mobile: sendBiometricMatch", { match });
+    return await browser.execute("mobile: sendBiometricMatch", { match, type });
   } catch (err) {
     if (!isUnknownMethodError(err)) {
       throw err;
@@ -6560,14 +6564,31 @@ async function toggleEnrollTouchId(enabled) {
 }
 
 // src/commands/mobile/launchApp.ts
-async function launchApp() {
+async function launchApp(options) {
+  var _a, _b;
   const browser = this;
   if (!browser.isMobile) {
     throw new Error("The `launchApp` command is only available for mobile platforms.");
   }
-  const mobileCmd = browser.isIOS ? "mobile: launchApp" : "mobile: activateApp";
+  let mobileCmd;
+  let mobileArgs;
+  if (browser.isIOS) {
+    mobileCmd = "mobile: launchApp";
+    const bundleId = (_a = options == null ? void 0 : options.bundleId) != null ? _a : (await browser.execute("mobile: activeAppInfo")).bundleId;
+    mobileArgs = { bundleId };
+    if ((options == null ? void 0 : options.arguments) !== void 0) {
+      mobileArgs.arguments = options.arguments;
+    }
+    if ((options == null ? void 0 : options.environment) !== void 0) {
+      mobileArgs.environment = options.environment;
+    }
+  } else {
+    mobileCmd = "mobile: activateApp";
+    const appId = (_b = options == null ? void 0 : options.appId) != null ? _b : await browser.getCurrentPackage();
+    mobileArgs = { appId };
+  }
   try {
-    return await browser.execute(mobileCmd, {});
+    return await browser.execute(mobileCmd, mobileArgs);
   } catch (err) {
     if (!isUnknownMethodError(err)) {
       throw err;
@@ -6723,13 +6744,14 @@ async function toggleWiFi(enabled) {
 }
 
 // src/commands/mobile/unlock.ts
-async function unlock() {
+async function unlock(options) {
   const browser = this;
   if (!browser.isMobile) {
     throw new Error("The `unlock` command is only available for mobile platforms.");
   }
+  const args = browser.isAndroid && options ? { ...options } : {};
   try {
-    return await browser.execute("mobile: unlock", {});
+    return await browser.execute("mobile: unlock", args);
   } catch (err) {
     if (!isUnknownMethodError(err)) {
       throw err;
@@ -6777,13 +6799,22 @@ async function shake() {
 }
 
 // src/commands/mobile/closeApp.ts
-async function closeApp() {
+async function closeApp(options) {
+  var _a, _b;
   const browser = this;
   if (!browser.isMobile) {
     throw new Error("The `closeApp` command is only available for mobile platforms.");
   }
+  let terminateArgs;
+  if (browser.isIOS) {
+    const bundleId = (_a = options == null ? void 0 : options.bundleId) != null ? _a : (await browser.execute("mobile: activeAppInfo")).bundleId;
+    terminateArgs = { bundleId };
+  } else {
+    const appId = (_b = options == null ? void 0 : options.appId) != null ? _b : await browser.getCurrentPackage();
+    terminateArgs = { appId };
+  }
   try {
-    return await browser.execute("mobile: terminateApp", {});
+    return await browser.execute("mobile: terminateApp", terminateArgs);
   } catch (err) {
     if (!isUnknownMethodError(err)) {
       throw err;
@@ -6963,7 +6994,11 @@ async function sendKeyEvent(keycode, metastate) {
     throw new Error("The `sendKeyEvent` command is only available for Android.");
   }
   try {
-    return await browser.execute("mobile: pressKey", { keycode, metastate });
+    const args = { keycode: parseInt(keycode, 10) };
+    if (metastate !== void 0) {
+      args.metastate = parseInt(metastate, 10);
+    }
+    return await browser.execute("mobile: pressKey", args);
   } catch (err) {
     if (!isUnknownMethodError(err)) {
       throw err;
@@ -6974,7 +7009,7 @@ async function sendKeyEvent(keycode, metastate) {
 }
 
 // src/commands/mobile/startActivity.ts
-async function startActivity(appPackage, appActivity, appWaitPackage, appWaitActivity, intentAction, intentCategory, intentFlags, optionalIntentArguments, dontStopAppOnReset) {
+async function startActivity(appPackageOrOptions, appActivity, appWaitPackage, appWaitActivity, intentAction, intentCategory, intentFlags, optionalIntentArguments, dontStopAppOnReset) {
   const browser = this;
   if (!browser.isMobile) {
     throw new Error("The `startActivity` command is only available for mobile platforms.");
@@ -6982,33 +7017,49 @@ async function startActivity(appPackage, appActivity, appWaitPackage, appWaitAct
   if (!browser.isAndroid) {
     throw new Error("The `startActivity` command is only available for Android.");
   }
+  const opts = typeof appPackageOrOptions === "object" ? appPackageOrOptions : {
+    appPackage: appPackageOrOptions,
+    appActivity,
+    appWaitPackage,
+    appWaitActivity,
+    intentAction,
+    intentCategory,
+    intentFlags,
+    optionalIntentArguments,
+    dontStopAppOnReset
+  };
+  const mobileArgs = {
+    component: "".concat(opts.appPackage, "/").concat(opts.appActivity)
+  };
+  if (opts.intentAction !== void 0) {
+    mobileArgs.action = opts.intentAction;
+  }
+  if (opts.intentCategory !== void 0) {
+    mobileArgs.categories = opts.intentCategory;
+  }
+  if (opts.intentFlags !== void 0) {
+    mobileArgs.flags = opts.intentFlags;
+  }
+  if (opts.dontStopAppOnReset !== void 0) {
+    mobileArgs.stop = opts.dontStopAppOnReset !== "true";
+  }
   try {
-    return await browser.execute("mobile: startActivity", {
-      appPackage,
-      appActivity,
-      appWaitPackage,
-      appWaitActivity,
-      intentAction,
-      intentCategory,
-      intentFlags,
-      optionalIntentArguments,
-      dontStopAppOnReset
-    });
+    return await browser.execute("mobile: startActivity", mobileArgs);
   } catch (err) {
     if (!isUnknownMethodError(err)) {
       throw err;
     }
     logAppiumDeprecationWarning("mobile: startActivity", "/appium/device/start_activity");
     return browser.appiumStartActivity(
-      appPackage,
-      appActivity,
-      appWaitPackage,
-      appWaitActivity,
-      intentAction,
-      intentCategory,
-      intentFlags,
-      optionalIntentArguments,
-      dontStopAppOnReset
+      opts.appPackage,
+      opts.appActivity,
+      opts.appWaitPackage,
+      opts.appWaitActivity,
+      opts.intentAction,
+      opts.intentCategory,
+      opts.intentFlags,
+      opts.optionalIntentArguments,
+      opts.dontStopAppOnReset
     );
   }
 }
@@ -7109,7 +7160,7 @@ async function gsmSignal(signalStrength) {
       throw err;
     }
     logAppiumDeprecationWarning("mobile: gsmSignal", "/appium/device/gsm_signal");
-    return browser.appiumGsmSignal(signalStrength);
+    return browser.appiumGsmSignal(String(signalStrength));
   }
 }
 

package/build/node.js

@@ -6507,7 +6507,7 @@ async function relaunchActiveApp() {
 }
 
 // src/commands/mobile/deepLink.ts
-async function deepLink(link, appIdentifier) {
+async function deepLink(link, appIdentifier, waitForLaunch) {
   const browser = this;
   if (!browser.isMobile) {
     throw new Error("The `deepLink` command is only available for mobile platforms.");
@@ -6520,10 +6520,14 @@ async function deepLink(link, appIdentifier) {
     const identifierValue = browser.isIOS ? "bundleId" : "package";
     throw new Error(`When using a deep link URL for ${mobileOS}, you need to provide the \`${identifierValue}\` of the app that the deep link should open.`);
   }
-  return browser.execute("mobile:deepLink", {
+  const args = {
     url: link,
     [browser.isIOS ? "bundleId" : "package"]: appIdentifier
-  });
+  };
+  if (!browser.isIOS && waitForLaunch !== void 0) {
+    args.waitForLaunch = waitForLaunch;
+  }
+  return browser.execute("mobile:deepLink", args);
 }
 function isDeepLinkUrl(link) {
   const deepLinkRegex = /^(?!https?:\/\/)[a-zA-Z][\w+\-.]*:\/\//;
@@ -6548,7 +6552,7 @@ async function lock(seconds) {
 }
 
 // src/commands/mobile/touchId.ts
-async function touchId(match) {
+async function touchId(match, type = "touchId") {
   const browser = this;
   if (!browser.isMobile) {
     throw new Error("The `touchId` command is only available for mobile platforms.");
@@ -6557,7 +6561,7 @@ async function touchId(match) {
     throw new Error("The `touchId` command is only available for iOS. For Android, use `fingerPrint` instead.");
   }
   try {
-    return await browser.execute("mobile: sendBiometricMatch", { match });
+    return await browser.execute("mobile: sendBiometricMatch", { match, type });
   } catch (err) {
     if (!isUnknownMethodError(err)) {
       throw err;
@@ -6588,14 +6592,30 @@ async function toggleEnrollTouchId(enabled) {
 }
 
 // src/commands/mobile/launchApp.ts
-async function launchApp() {
+async function launchApp(options) {
   const browser = this;
   if (!browser.isMobile) {
     throw new Error("The `launchApp` command is only available for mobile platforms.");
   }
-  const mobileCmd = browser.isIOS ? "mobile: launchApp" : "mobile: activateApp";
+  let mobileCmd;
+  let mobileArgs;
+  if (browser.isIOS) {
+    mobileCmd = "mobile: launchApp";
+    const bundleId = options?.bundleId ?? (await browser.execute("mobile: activeAppInfo")).bundleId;
+    mobileArgs = { bundleId };
+    if (options?.arguments !== void 0) {
+      mobileArgs.arguments = options.arguments;
+    }
+    if (options?.environment !== void 0) {
+      mobileArgs.environment = options.environment;
+    }
+  } else {
+    mobileCmd = "mobile: activateApp";
+    const appId = options?.appId ?? await browser.getCurrentPackage();
+    mobileArgs = { appId };
+  }
   try {
-    return await browser.execute(mobileCmd, {});
+    return await browser.execute(mobileCmd, mobileArgs);
   } catch (err) {
     if (!isUnknownMethodError(err)) {
       throw err;
@@ -6751,13 +6771,14 @@ async function toggleWiFi(enabled) {
 }
 
 // src/commands/mobile/unlock.ts
-async function unlock() {
+async function unlock(options) {
   const browser = this;
   if (!browser.isMobile) {
     throw new Error("The `unlock` command is only available for mobile platforms.");
   }
+  const args = browser.isAndroid && options ? { ...options } : {};
   try {
-    return await browser.execute("mobile: unlock", {});
+    return await browser.execute("mobile: unlock", args);
   } catch (err) {
     if (!isUnknownMethodError(err)) {
       throw err;
@@ -6805,13 +6826,21 @@ async function shake() {
 }
 
 // src/commands/mobile/closeApp.ts
-async function closeApp() {
+async function closeApp(options) {
   const browser = this;
   if (!browser.isMobile) {
     throw new Error("The `closeApp` command is only available for mobile platforms.");
   }
+  let terminateArgs;
+  if (browser.isIOS) {
+    const bundleId = options?.bundleId ?? (await browser.execute("mobile: activeAppInfo")).bundleId;
+    terminateArgs = { bundleId };
+  } else {
+    const appId = options?.appId ?? await browser.getCurrentPackage();
+    terminateArgs = { appId };
+  }
   try {
-    return await browser.execute("mobile: terminateApp", {});
+    return await browser.execute("mobile: terminateApp", terminateArgs);
   } catch (err) {
     if (!isUnknownMethodError(err)) {
       throw err;
@@ -6991,7 +7020,11 @@ async function sendKeyEvent(keycode, metastate) {
     throw new Error("The `sendKeyEvent` command is only available for Android.");
   }
   try {
-    return await browser.execute("mobile: pressKey", { keycode, metastate });
+    const args = { keycode: parseInt(keycode, 10) };
+    if (metastate !== void 0) {
+      args.metastate = parseInt(metastate, 10);
+    }
+    return await browser.execute("mobile: pressKey", args);
   } catch (err) {
     if (!isUnknownMethodError(err)) {
       throw err;
@@ -7002,7 +7035,7 @@ async function sendKeyEvent(keycode, metastate) {
 }
 
 // src/commands/mobile/startActivity.ts
-async function startActivity(appPackage, appActivity, appWaitPackage, appWaitActivity, intentAction, intentCategory, intentFlags, optionalIntentArguments, dontStopAppOnReset) {
+async function startActivity(appPackageOrOptions, appActivity, appWaitPackage, appWaitActivity, intentAction, intentCategory, intentFlags, optionalIntentArguments, dontStopAppOnReset) {
   const browser = this;
   if (!browser.isMobile) {
     throw new Error("The `startActivity` command is only available for mobile platforms.");
@@ -7010,33 +7043,49 @@ async function startActivity(appPackage, appActivity, appWaitPackage, appWaitAct
   if (!browser.isAndroid) {
     throw new Error("The `startActivity` command is only available for Android.");
   }
+  const opts = typeof appPackageOrOptions === "object" ? appPackageOrOptions : {
+    appPackage: appPackageOrOptions,
+    appActivity,
+    appWaitPackage,
+    appWaitActivity,
+    intentAction,
+    intentCategory,
+    intentFlags,
+    optionalIntentArguments,
+    dontStopAppOnReset
+  };
+  const mobileArgs = {
+    component: `${opts.appPackage}/${opts.appActivity}`
+  };
+  if (opts.intentAction !== void 0) {
+    mobileArgs.action = opts.intentAction;
+  }
+  if (opts.intentCategory !== void 0) {
+    mobileArgs.categories = opts.intentCategory;
+  }
+  if (opts.intentFlags !== void 0) {
+    mobileArgs.flags = opts.intentFlags;
+  }
+  if (opts.dontStopAppOnReset !== void 0) {
+    mobileArgs.stop = opts.dontStopAppOnReset !== "true";
+  }
   try {
-    return await browser.execute("mobile: startActivity", {
-      appPackage,
-      appActivity,
-      appWaitPackage,
-      appWaitActivity,
-      intentAction,
-      intentCategory,
-      intentFlags,
-      optionalIntentArguments,
-      dontStopAppOnReset
-    });
+    return await browser.execute("mobile: startActivity", mobileArgs);
   } catch (err) {
     if (!isUnknownMethodError(err)) {
       throw err;
     }
     logAppiumDeprecationWarning("mobile: startActivity", "/appium/device/start_activity");
     return browser.appiumStartActivity(
-      appPackage,
-      appActivity,
-      appWaitPackage,
-      appWaitActivity,
-      intentAction,
-      intentCategory,
-      intentFlags,
-      optionalIntentArguments,
-      dontStopAppOnReset
+      opts.appPackage,
+      opts.appActivity,
+      opts.appWaitPackage,
+      opts.appWaitActivity,
+      opts.intentAction,
+      opts.intentCategory,
+      opts.intentFlags,
+      opts.optionalIntentArguments,
+      opts.dontStopAppOnReset
     );
   }
 }
@@ -7137,7 +7186,7 @@ async function gsmSignal(signalStrength) {
       throw err;
     }
     logAppiumDeprecationWarning("mobile: gsmSignal", "/appium/device/gsm_signal");
-    return browser.appiumGsmSignal(signalStrength);
+    return browser.appiumGsmSignal(String(signalStrength));
   }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "webdriverio",
   "description": "Next-gen browser and mobile automation test framework for Node.js",
-  "version": "9.26.0",
+  "version": "9.26.1",
   "homepage": "https://webdriver.io",
   "author": "Christian Bromann <mail@bromann.dev>",
   "license": "MIT",
@@ -77,12 +77,12 @@
   "dependencies": {
     "@types/node": "^20.11.30",
     "@types/sinonjs__fake-timers": "^8.1.5",
-    "@wdio/config": "9.26.0",
+    "@wdio/config": "9.26.1",
     "@wdio/logger": "9.18.0",
-    "@wdio/protocols": "9.26.0",
+    "@wdio/protocols": "9.26.1",
     "@wdio/repl": "9.16.2",
-    "@wdio/types": "9.26.0",
-    "@wdio/utils": "9.26.0",
+    "@wdio/types": "9.26.1",
+    "@wdio/utils": "9.26.1",
     "archiver": "^7.0.1",
     "aria-query": "^5.3.0",
     "cheerio": "^1.0.0-rc.12",
@@ -99,7 +99,7 @@
     "rgb2hex": "0.2.5",
     "serialize-error": "^12.0.0",
     "urlpattern-polyfill": "^10.0.0",
-    "webdriver": "9.26.0"
+    "webdriver": "9.26.1"
   },
   "peerDependencies": {
     "puppeteer-core": ">=22.x || <=24.x"
@@ -109,5 +109,5 @@
       "optional": true
     }
   },
-  "gitHead": "974fb5ead9fe6738af6f5e2306224036de552f33"
+  "gitHead": "0149a736235a2fb00f84a50652193bb92c24cd8f"
 }