@midscene/android 1.8.0 → 1.8.1

package/dist/es/index.mjs

@@ -5,7 +5,7 @@ import * as __rspack_external_node_path_c5b9b54f from "node:path";
 import node_assert from "node:assert";
 import { execFile } from "node:child_process";
 import { getMidsceneLocationSchema, z } from "@midscene/core";
-import { defineAction, defineActionClearInput, defineActionCursorMove, defineActionDoubleClick, defineActionDragAndDrop, defineActionKeyboardPress, defineActionLongPress, defineActionPinch, defineActionScroll, defineActionSwipe, defineActionTap, normalizeMobileSwipeParam, normalizePinchParam } from "@midscene/core/device";
+import { createDefaultMobileActions, defineAction } from "@midscene/core/device";
 import { getTmpFile, sleep } from "@midscene/core/utils";
 import { MIDSCENE_ADB_PATH, MIDSCENE_ADB_REMOTE_HOST, MIDSCENE_ADB_REMOTE_PORT, MIDSCENE_ANDROID_IME_STRATEGY, globalConfigManager, overrideAIConfig } from "@midscene/shared/env";
 import { createImgBase64ByFormat, validateScreenshotBuffer } from "@midscene/shared/img";
@@ -587,103 +587,30 @@ function escapeForShell(text) {
 }
 class AndroidDevice {
     actionSpace() {
-        const defaultActions = [
-            defineActionTap(async (param)=>{
-                const element = param.locate;
-                node_assert(element, 'Element not found, cannot tap');
-                await this.mouseClick(element.center[0], element.center[1]);
-            }),
-            defineActionDoubleClick(async (param)=>{
-                const element = param.locate;
-                node_assert(element, 'Element not found, cannot double click');
-                await this.mouseDoubleClick(element.center[0], element.center[1]);
-            }),
-            defineAction({
-                name: 'Input',
-                description: 'Input text into the input field',
-                interfaceAlias: 'aiInput',
-                paramSchema: z.object({
-                    value: z.string().describe('The text to input. Provide the final content for replace/append modes, or an empty string when using clear mode to remove existing text.'),
-                    autoDismissKeyboard: z.boolean().optional().describe('If true, the keyboard will be dismissed after the input is completed. Do not set it unless the user asks you to do so.'),
-                    mode: z.preprocess((val)=>'append' === val ? 'typeOnly' : val, z["enum"]([
-                        'replace',
-                        'clear',
-                        'typeOnly'
-                    ]).default('replace').optional().describe('Input mode: "replace" (default) - clear the field and input the value; "typeOnly" - type the value directly without clearing the field first; "clear" - clear the field without inputting new text.')),
-                    locate: getMidsceneLocationSchema().describe('The input field to be filled').optional()
-                }),
-                sample: {
-                    value: 'test@example.com',
-                    locate: {
-                        prompt: 'the email input field'
-                    }
+        const mobileActionContext = {
+            input: this.inputPrimitives,
+            size: ()=>this.size(),
+            sleep: async (timeMs)=>{
+                await sleep(timeMs);
+            },
+            getDefaultAutoDismissKeyboard: ()=>this.options?.autoDismissKeyboard,
+            systemActions: {
+                backButton: {
+                    name: 'AndroidBackButton',
+                    description: 'Trigger the system "back" operation on Android devices'
                 },
-                call: async (param)=>{
-                    const element = param.locate;
-                    if ('typeOnly' !== param.mode) await this.clearInput(element);
-                    if ('clear' === param.mode) return;
-                    if (!param || !param.value) return;
-                    const autoDismissKeyboard = param.autoDismissKeyboard ?? this.options?.autoDismissKeyboard;
-                    await this.keyboardType(param.value, {
-                        autoDismissKeyboard
-                    });
-                }
-            }),
-            defineActionScroll(async (param)=>{
-                const element = param.locate;
-                const startingPoint = element ? {
-                    left: element.center[0],
-                    top: element.center[1]
-                } : void 0;
-                const scrollToEventName = param?.scrollType;
-                if ('scrollToTop' === scrollToEventName) await this.scrollUntilTop(startingPoint);
-                else if ('scrollToBottom' === scrollToEventName) await this.scrollUntilBottom(startingPoint);
-                else if ('scrollToRight' === scrollToEventName) await this.scrollUntilRight(startingPoint);
-                else if ('scrollToLeft' === scrollToEventName) await this.scrollUntilLeft(startingPoint);
-                else if ('singleAction' !== scrollToEventName && scrollToEventName) throw new Error(`Unknown scroll event type: ${scrollToEventName}, param: ${JSON.stringify(param)}`);
-                else {
-                    if (param?.direction !== 'down' && param && param.direction) if ('up' === param.direction) await this.scrollUp(param.distance || void 0, startingPoint);
-                    else if ('left' === param.direction) await this.scrollLeft(param.distance || void 0, startingPoint);
-                    else if ('right' === param.direction) await this.scrollRight(param.distance || void 0, startingPoint);
-                    else throw new Error(`Unknown scroll direction: ${param.direction}`);
-                    else await this.scrollDown(param?.distance || void 0, startingPoint);
-                    await sleep(500);
-                }
-            }),
-            defineActionDragAndDrop(async (param)=>{
-                const from = param.from;
-                const to = param.to;
-                node_assert(from, 'missing "from" param for drag and drop');
-                node_assert(to, 'missing "to" param for drag and drop');
-                await this.mouseDrag({
-                    x: from.center[0],
-                    y: from.center[1]
-                }, {
-                    x: to.center[0],
-                    y: to.center[1]
-                });
-            }),
-            defineActionSwipe(async (param)=>{
-                const { startPoint, endPoint, duration, repeatCount } = normalizeMobileSwipeParam(param, await this.size());
-                for(let i = 0; i < repeatCount; i++)await this.mouseDrag(startPoint, endPoint, duration);
-            }),
-            defineActionKeyboardPress(async (param)=>{
-                await this.keyboardPress(param.keyName);
-            }),
-            defineActionCursorMove(async (param)=>{
-                const arrowKey = 'left' === param.direction ? 'ArrowLeft' : 'ArrowRight';
-                const times = param.times ?? 1;
-                for(let i = 0; i < times; i++){
-                    await this.keyboardPress(arrowKey);
-                    await sleep(100);
+                homeButton: {
+                    name: 'AndroidHomeButton',
+                    description: 'Trigger the system "home" operation on Android devices'
+                },
+                recentAppsButton: {
+                    name: 'AndroidRecentAppsButton',
+                    description: 'Trigger the system "recent apps" operation on Android devices'
                 }
-            }),
-            defineActionLongPress(async (param)=>{
-                const element = param.locate;
-                if (!element) throw new Error('LongPress requires an element to be located');
-                const [x, y] = element.center;
-                await this.longPress(x, y, param?.duration);
-            }),
+            }
+        };
+        const defaultActions = [
+            ...createDefaultMobileActions(mobileActionContext),
             defineAction({
                 name: 'PullGesture',
                 description: 'Trigger pull down to refresh or pull up actions',
@@ -713,19 +640,6 @@ class AndroidDevice {
                     else if ('up' === param.direction) await this.pullUp(startPoint, param.distance, param.duration);
                     else throw new Error(`Unknown pull direction: ${param.direction}`);
                 }
-            }),
-            defineActionPinch(async (param)=>{
-                const { centerX, centerY, startDistance, endDistance, duration } = normalizePinchParam(param, await this.size());
-                const { x: adjCenterX, y: adjCenterY } = await this.adjustCoordinates(centerX, centerY);
-                const ratio = 0 !== adjCenterX && 0 !== centerX ? adjCenterX / centerX : 1;
-                const adjStartDist = Math.round(startDistance * ratio);
-                const adjEndDist = Math.round(endDistance * ratio);
-                await this.ensureYadb();
-                const adb = await this.getAdb();
-                await adb.shell(`app_process${this.getDisplayArg()} -Djava.class.path=/data/local/tmp/yadb /data/local/tmp com.ysbing.yadb.Main -pinch ${adjCenterX} ${adjCenterY} ${adjStartDist} ${adjEndDist} ${duration}`);
-            }),
-            defineActionClearInput(async (param)=>{
-                await this.clearInput(param.locate);
             })
         ];
         const platformSpecificActions = Object.values(createPlatformActions(this));
@@ -736,6 +650,27 @@ class AndroidDevice {
             ...customActions
         ];
     }
+    async performActionScroll(param) {
+        const element = param.locate;
+        const startingPoint = element ? {
+            left: element.center[0],
+            top: element.center[1]
+        } : void 0;
+        const scrollToEventName = param?.scrollType;
+        if ('scrollToTop' === scrollToEventName) await this.scrollUntilTop(startingPoint);
+        else if ('scrollToBottom' === scrollToEventName) await this.scrollUntilBottom(startingPoint);
+        else if ('scrollToRight' === scrollToEventName) await this.scrollUntilRight(startingPoint);
+        else if ('scrollToLeft' === scrollToEventName) await this.scrollUntilLeft(startingPoint);
+        else if ('singleAction' !== scrollToEventName && scrollToEventName) throw new Error(`Unknown scroll event type: ${scrollToEventName}, param: ${JSON.stringify(param)}`);
+        else {
+            if (param?.direction !== 'down' && param && param.direction) if ('up' === param.direction) await this.scrollUp(param.distance || void 0, startingPoint);
+            else if ('left' === param.direction) await this.scrollLeft(param.distance || void 0, startingPoint);
+            else if ('right' === param.direction) await this.scrollRight(param.distance || void 0, startingPoint);
+            else throw new Error(`Unknown scroll direction: ${param.direction}`);
+            else await this.scrollDown(param?.distance || void 0, startingPoint);
+            await sleep(500);
+        }
+    }
     describe() {
         return this.description || `DeviceId: ${this.deviceId}`;
     }
@@ -1223,14 +1158,20 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
         return result;
     }
     async clearInput(element) {
-        if (element) await this.mouseClick(element.center[0], element.center[1]);
+        if (element) await this.tapPoint({
+            x: element.center[0],
+            y: element.center[1]
+        });
         await this.ensureYadb();
         const adb = await this.getAdb();
         const IME_STRATEGY = (this.options?.imeStrategy || globalConfigManager.getEnvConfigValue(MIDSCENE_ANDROID_IME_STRATEGY)) ?? IME_STRATEGY_YADB_FOR_NON_ASCII;
         if (IME_STRATEGY === IME_STRATEGY_YADB_FOR_NON_ASCII) await adb.clearTextField(100);
         else await adb.shell(`app_process${this.getDisplayArg()} -Djava.class.path=/data/local/tmp/yadb /data/local/tmp com.ysbing.yadb.Main -keyboardClear`);
         if (await adb.isSoftKeyboardPresent()) return;
-        if (element) await this.mouseClick(element.center[0], element.center[1]);
+        if (element) await this.tapPoint({
+            x: element.center[0],
+            y: element.center[1]
+        });
     }
     async forceScreenshot(path) {
         await this.ensureYadb();
@@ -1251,7 +1192,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
                 x: start.x,
                 y: Math.round(height)
             };
-            await repeat(defaultScrollUntilTimes, ()=>this.mouseDrag(start, end, defaultFastScrollDuration));
+            await repeat(defaultScrollUntilTimes, ()=>this.dragPoint(start, end, defaultFastScrollDuration));
             await sleep(1000);
             return;
         }
@@ -1268,7 +1209,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
                 x: start.x,
                 y: 0
             };
-            await repeat(defaultScrollUntilTimes, ()=>this.mouseDrag(start, end, defaultFastScrollDuration));
+            await repeat(defaultScrollUntilTimes, ()=>this.dragPoint(start, end, defaultFastScrollDuration));
             await sleep(1000);
             return;
         }
@@ -1286,7 +1227,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
                 x: Math.round(width),
                 y: start.y
             };
-            await repeat(defaultScrollUntilTimes, ()=>this.mouseDrag(start, end, defaultFastScrollDuration));
+            await repeat(defaultScrollUntilTimes, ()=>this.dragPoint(start, end, defaultFastScrollDuration));
             await sleep(1000);
             return;
         }
@@ -1303,7 +1244,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
                 x: 0,
                 y: start.y
             };
-            await repeat(defaultScrollUntilTimes, ()=>this.mouseDrag(start, end, defaultFastScrollDuration));
+            await repeat(defaultScrollUntilTimes, ()=>this.dragPoint(start, end, defaultFastScrollDuration));
             await sleep(1000);
             return;
         }
@@ -1321,7 +1262,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
             };
             const end = this.calculateScrollEndPoint(start, 0, scrollDistance, 0, height);
             if (hasExplicitDistance) this.warnScrollDistanceClamped('up', scrollDistance, Math.abs(end.y - start.y));
-            await this.mouseDrag(start, end);
+            await this.dragPoint(start, end);
             return;
         }
         await this.scroll(0, -scrollDistance, void 0, hasExplicitDistance, 'up');
@@ -1337,7 +1278,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
             };
             const end = this.calculateScrollEndPoint(start, 0, -scrollDistance, 0, height);
             if (hasExplicitDistance) this.warnScrollDistanceClamped('down', scrollDistance, Math.abs(end.y - start.y));
-            await this.mouseDrag(start, end);
+            await this.dragPoint(start, end);
             return;
         }
         await this.scroll(0, scrollDistance, void 0, hasExplicitDistance, 'down');
@@ -1353,7 +1294,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
             };
             const end = this.calculateScrollEndPoint(start, scrollDistance, 0, width, 0);
             if (hasExplicitDistance) this.warnScrollDistanceClamped('left', scrollDistance, Math.abs(end.x - start.x));
-            await this.mouseDrag(start, end);
+            await this.dragPoint(start, end);
             return;
         }
         await this.scroll(-scrollDistance, 0, void 0, hasExplicitDistance, 'left');
@@ -1369,7 +1310,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
             };
             const end = this.calculateScrollEndPoint(start, -scrollDistance, 0, width, 0);
             if (hasExplicitDistance) this.warnScrollDistanceClamped('right', scrollDistance, Math.abs(end.x - start.x));
-            await this.mouseDrag(start, end);
+            await this.dragPoint(start, end);
             return;
         }
         await this.scroll(scrollDistance, 0, void 0, hasExplicitDistance, 'right');
@@ -1390,7 +1331,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
         const hasBothQuotes = text.includes('"') && text.includes("'");
         return hasNonAscii || hasFormatSpecifiers || hasShellSpecialChars || hasBothQuotes;
     }
-    async keyboardType(text, options) {
+    async typeText(text, options) {
         if (!text) return;
         const adb = await this.getAdb();
         const IME_STRATEGY = (this.options?.imeStrategy || globalConfigManager.getEnvConfigValue(MIDSCENE_ANDROID_IME_STRATEGY)) ?? IME_STRATEGY_YADB_FOR_NON_ASCII;
@@ -1427,7 +1368,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
         const lowerKey = key.toLowerCase();
         return keyMap[lowerKey] || key;
     }
-    async keyboardPress(key) {
+    async pressKey(key) {
         const keyCodeMap = {
             Enter: 66,
             Backspace: 67,
@@ -1449,14 +1390,14 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
             if (asciiCode >= 65 && asciiCode <= 90) await adb.keyevent(asciiCode - 36);
         }
     }
-    async mouseClick(x, y) {
+    async tapPoint(point) {
         const adb = await this.getAdb();
-        const { x: adjustedX, y: adjustedY } = await this.adjustCoordinates(x, y);
+        const { x: adjustedX, y: adjustedY } = await this.adjustCoordinates(point.x, point.y);
         await adb.shell(`input${this.getDisplayArg()} swipe ${adjustedX} ${adjustedY} ${adjustedX} ${adjustedY} 150`);
     }
-    async mouseDoubleClick(x, y) {
+    async doubleTapPoint(point) {
         const adb = await this.getAdb();
-        const { x: adjustedX, y: adjustedY } = await this.adjustCoordinates(x, y);
+        const { x: adjustedX, y: adjustedY } = await this.adjustCoordinates(point.x, point.y);
         const tapCommand = `input${this.getDisplayArg()} tap ${adjustedX} ${adjustedY}`;
         await adb.shell(tapCommand);
         await sleep(50);
@@ -1465,12 +1406,14 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
     async mouseMove() {
         return Promise.resolve();
     }
-    async mouseDrag(from, to, duration) {
+    async dragPoint(from, to, duration) {
+        await this.swipePoint(from, to, duration ?? defaultNormalScrollDuration);
+    }
+    async swipePoint(from, to, duration) {
         const adb = await this.getAdb();
         const { x: fromX, y: fromY } = await this.adjustCoordinates(from.x, from.y);
         const { x: toX, y: toY } = await this.adjustCoordinates(to.x, to.y);
-        const swipeDuration = duration ?? defaultNormalScrollDuration;
-        await adb.shell(`input${this.getDisplayArg()} swipe ${fromX} ${fromY} ${toX} ${toY} ${swipeDuration}`);
+        await adb.shell(`input${this.getDisplayArg()} swipe ${fromX} ${fromY} ${toX} ${toY} ${duration}`);
     }
     async scroll(deltaX, deltaY, duration, warnOnClamp = false, direction) {
         if (0 === deltaX && 0 === deltaY) throw new Error('Scroll distance cannot be zero in both directions');
@@ -1493,11 +1436,14 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
         }
         const endX = Math.round(startX - deltaX);
         const endY = Math.round(startY - deltaY);
-        const { x: adjustedStartX, y: adjustedStartY } = await this.adjustCoordinates(startX, startY);
-        const { x: adjustedEndX, y: adjustedEndY } = await this.adjustCoordinates(endX, endY);
-        const adb = await this.getAdb();
         const swipeDuration = duration ?? defaultNormalScrollDuration;
-        await adb.shell(`input${this.getDisplayArg()} swipe ${adjustedStartX} ${adjustedStartY} ${adjustedEndX} ${adjustedEndY} ${swipeDuration}`);
+        await this.swipePoint({
+            x: startX,
+            y: startY
+        }, {
+            x: endX,
+            y: endY
+        }, swipeDuration);
     }
     async destroy() {
         if (this.destroyed) return;
@@ -1545,9 +1491,9 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
         const adb = await this.getAdb();
         await adb.shell(`input${this.getDisplayArg()} keyevent 187`);
     }
-    async longPress(x, y, duration = 2000) {
+    async longPressPoint(point, duration = 2000) {
         const adb = await this.getAdb();
-        const { x: adjustedX, y: adjustedY } = await this.adjustCoordinates(x, y);
+        const { x: adjustedX, y: adjustedY } = await this.adjustCoordinates(point.x, point.y);
         await adb.shell(`input${this.getDisplayArg()} swipe ${adjustedX} ${adjustedY} ${adjustedX} ${adjustedY} ${duration}`);
     }
     async pullDown(startPoint, distance, duration = 800) {
@@ -1568,10 +1514,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
         await sleep(200);
     }
     async pullDrag(from, to, duration) {
-        const adb = await this.getAdb();
-        const { x: fromX, y: fromY } = await this.adjustCoordinates(from.x, from.y);
-        const { x: toX, y: toY } = await this.adjustCoordinates(to.x, to.y);
-        await adb.shell(`input${this.getDisplayArg()} swipe ${fromX} ${fromY} ${toX} ${toY} ${duration}`);
+        await this.swipePoint(from, to, duration);
     }
     async pullUp(startPoint, distance, duration = 600) {
         const { width, height } = await this.size();
@@ -1672,6 +1615,56 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
         device_define_property(this, "interfaceType", 'android');
         device_define_property(this, "uri", void 0);
         device_define_property(this, "options", void 0);
+        device_define_property(this, "inputPrimitives", {
+            pointer: {
+                tap: (point)=>this.tapPoint(point),
+                doubleClick: (point)=>this.doubleTapPoint(point),
+                longPress: (point, opts)=>this.longPressPoint(point, opts?.duration),
+                dragAndDrop: (from, to)=>this.dragPoint(from, to)
+            },
+            keyboard: {
+                keyboardPress: (keyName)=>this.pressKey(keyName),
+                typeText: async (value, opts)=>{
+                    const target = opts?.target;
+                    if (target && opts?.replace !== false) await this.clearInput(target);
+                    else if (target) await this.tapPoint({
+                        x: target.center[0],
+                        y: target.center[1]
+                    });
+                    if (opts?.focusOnly) return;
+                    await this.typeText(value, opts);
+                },
+                clearInput: (target)=>this.clearInput(target),
+                cursorMove: async (direction, times = 1)=>{
+                    const arrowKey = 'left' === direction ? 'ArrowLeft' : 'ArrowRight';
+                    for(let i = 0; i < times; i++)await this.pressKey(arrowKey);
+                }
+            },
+            touch: {
+                swipe: async (start, end, opts)=>{
+                    const duration = opts?.duration ?? 300;
+                    const repeatCount = opts?.repeat ?? 1;
+                    for(let i = 0; i < repeatCount; i++)await this.dragPoint(start, end, duration);
+                },
+                pinch: async (center, opts)=>{
+                    const { x: adjCenterX, y: adjCenterY } = await this.adjustCoordinates(Math.round(center.x), Math.round(center.y));
+                    const ratio = 0 !== adjCenterX && 0 !== center.x ? adjCenterX / center.x : 1;
+                    const adjStartDist = Math.round(opts.startDistance * ratio);
+                    const adjEndDist = Math.round(opts.endDistance * ratio);
+                    await this.ensureYadb();
+                    const adb = await this.getAdb();
+                    await adb.shell(`app_process${this.getDisplayArg()} -Djava.class.path=/data/local/tmp/yadb /data/local/tmp com.ysbing.yadb.Main -pinch ${adjCenterX} ${adjCenterY} ${adjStartDist} ${adjEndDist} ${opts.duration}`);
+                }
+            },
+            scroll: {
+                scroll: (param)=>this.performActionScroll(param)
+            },
+            system: {
+                backButton: ()=>this.back(),
+                homeButton: ()=>this.home(),
+                recentAppsButton: ()=>this.recentApps()
+            }
+        });
         node_assert(deviceId, 'deviceId is required for AndroidDevice');
         this.deviceId = deviceId;
         this.options = options;
@@ -1722,37 +1715,10 @@ const createPlatformActions = (device)=>({
             description: 'Terminate (force-stop) an Android app by package name',
             interfaceAlias: 'terminate',
             paramSchema: terminateParamSchema,
-            delayBeforeRunner: 0,
-            delayAfterRunner: 0,
             call: async (param)=>{
                 if (!param.uri || '' === param.uri.trim()) throw new Error('Terminate requires a non-empty uri parameter');
                 await device.terminate(param.uri);
             }
-        }),
-        AndroidBackButton: defineAction({
-            name: 'AndroidBackButton',
-            description: 'Trigger the system "back" operation on Android devices',
-            delayBeforeRunner: 0,
-            delayAfterRunner: 0,
-            call: async ()=>{
-                await device.back();
-            }
-        }),
-        AndroidHomeButton: defineAction({
-            name: 'AndroidHomeButton',
-            description: 'Trigger the system "home" operation on Android devices',
-            delayBeforeRunner: 0,
-            delayAfterRunner: 0,
-            call: async ()=>{
-                await device.home();
-            }
-        }),
-        AndroidRecentAppsButton: defineAction({
-            name: 'AndroidRecentAppsButton',
-            description: 'Trigger the system "recent apps" operation on Android devices',
-            call: async ()=>{
-                await device.recentApps();
-            }
         })
     });
 const defaultAppNameMapping = {