@midscene/android 1.8.0 → 1.8.1

package/dist/lib/mcp-server.js

@@ -714,103 +714,30 @@ var __webpack_exports__ = {};
     }
     class AndroidDevice {
         actionSpace() {
-            const defaultActions = [
-                (0, device_namespaceObject.defineActionTap)(async (param)=>{
-                    const element = param.locate;
-                    external_node_assert_default()(element, 'Element not found, cannot tap');
-                    await this.mouseClick(element.center[0], element.center[1]);
-                }),
-                (0, device_namespaceObject.defineActionDoubleClick)(async (param)=>{
-                    const element = param.locate;
-                    external_node_assert_default()(element, 'Element not found, cannot double click');
-                    await this.mouseDoubleClick(element.center[0], element.center[1]);
-                }),
-                (0, device_namespaceObject.defineAction)({
-                    name: 'Input',
-                    description: 'Input text into the input field',
-                    interfaceAlias: 'aiInput',
-                    paramSchema: core_namespaceObject.z.object({
-                        value: core_namespaceObject.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: core_namespaceObject.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: core_namespaceObject.z.preprocess((val)=>'append' === val ? 'typeOnly' : val, core_namespaceObject.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: (0, core_namespaceObject.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 (0, core_utils_namespaceObject.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
-                        });
-                    }
-                }),
-                (0, device_namespaceObject.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 (0, core_utils_namespaceObject.sleep)(500);
-                    }
-                }),
-                (0, device_namespaceObject.defineActionDragAndDrop)(async (param)=>{
-                    const from = param.from;
-                    const to = param.to;
-                    external_node_assert_default()(from, 'missing "from" param for drag and drop');
-                    external_node_assert_default()(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]
-                    });
-                }),
-                (0, device_namespaceObject.defineActionSwipe)(async (param)=>{
-                    const { startPoint, endPoint, duration, repeatCount } = (0, device_namespaceObject.normalizeMobileSwipeParam)(param, await this.size());
-                    for(let i = 0; i < repeatCount; i++)await this.mouseDrag(startPoint, endPoint, duration);
-                }),
-                (0, device_namespaceObject.defineActionKeyboardPress)(async (param)=>{
-                    await this.keyboardPress(param.keyName);
-                }),
-                (0, device_namespaceObject.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 (0, core_utils_namespaceObject.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'
                     }
-                }),
-                (0, device_namespaceObject.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 = [
+                ...(0, device_namespaceObject.createDefaultMobileActions)(mobileActionContext),
                 (0, device_namespaceObject.defineAction)({
                     name: 'PullGesture',
                     description: 'Trigger pull down to refresh or pull up actions',
@@ -840,19 +767,6 @@ var __webpack_exports__ = {};
                         else if ('up' === param.direction) await this.pullUp(startPoint, param.distance, param.duration);
                         else throw new Error(`Unknown pull direction: ${param.direction}`);
                     }
-                }),
-                (0, device_namespaceObject.defineActionPinch)(async (param)=>{
-                    const { centerX, centerY, startDistance, endDistance, duration } = (0, device_namespaceObject.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}`);
-                }),
-                (0, device_namespaceObject.defineActionClearInput)(async (param)=>{
-                    await this.clearInput(param.locate);
                 })
             ];
             const platformSpecificActions = Object.values(createPlatformActions(this));
@@ -863,6 +777,27 @@ var __webpack_exports__ = {};
                 ...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 (0, core_utils_namespaceObject.sleep)(500);
+            }
+        }
         describe() {
             return this.description || `DeviceId: ${this.deviceId}`;
         }
@@ -1350,14 +1285,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 || env_namespaceObject.globalConfigManager.getEnvConfigValue(env_namespaceObject.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();
@@ -1378,7 +1319,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
                     x: start.x,
                     y: Math.round(height)
                 };
-                await (0, utils_namespaceObject.repeat)(defaultScrollUntilTimes, ()=>this.mouseDrag(start, end, defaultFastScrollDuration));
+                await (0, utils_namespaceObject.repeat)(defaultScrollUntilTimes, ()=>this.dragPoint(start, end, defaultFastScrollDuration));
                 await (0, core_utils_namespaceObject.sleep)(1000);
                 return;
             }
@@ -1395,7 +1336,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
                     x: start.x,
                     y: 0
                 };
-                await (0, utils_namespaceObject.repeat)(defaultScrollUntilTimes, ()=>this.mouseDrag(start, end, defaultFastScrollDuration));
+                await (0, utils_namespaceObject.repeat)(defaultScrollUntilTimes, ()=>this.dragPoint(start, end, defaultFastScrollDuration));
                 await (0, core_utils_namespaceObject.sleep)(1000);
                 return;
             }
@@ -1413,7 +1354,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
                     x: Math.round(width),
                     y: start.y
                 };
-                await (0, utils_namespaceObject.repeat)(defaultScrollUntilTimes, ()=>this.mouseDrag(start, end, defaultFastScrollDuration));
+                await (0, utils_namespaceObject.repeat)(defaultScrollUntilTimes, ()=>this.dragPoint(start, end, defaultFastScrollDuration));
                 await (0, core_utils_namespaceObject.sleep)(1000);
                 return;
             }
@@ -1430,7 +1371,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
                     x: 0,
                     y: start.y
                 };
-                await (0, utils_namespaceObject.repeat)(defaultScrollUntilTimes, ()=>this.mouseDrag(start, end, defaultFastScrollDuration));
+                await (0, utils_namespaceObject.repeat)(defaultScrollUntilTimes, ()=>this.dragPoint(start, end, defaultFastScrollDuration));
                 await (0, core_utils_namespaceObject.sleep)(1000);
                 return;
             }
@@ -1448,7 +1389,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');
@@ -1464,7 +1405,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');
@@ -1480,7 +1421,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');
@@ -1496,7 +1437,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');
@@ -1517,7 +1458,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 || env_namespaceObject.globalConfigManager.getEnvConfigValue(env_namespaceObject.MIDSCENE_ANDROID_IME_STRATEGY)) ?? IME_STRATEGY_YADB_FOR_NON_ASCII;
@@ -1554,7 +1495,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,
@@ -1576,14 +1517,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 (0, core_utils_namespaceObject.sleep)(50);
@@ -1592,12 +1533,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');
@@ -1620,11 +1563,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;
@@ -1672,9 +1618,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) {
@@ -1695,10 +1641,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
             await (0, core_utils_namespaceObject.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();
@@ -1799,6 +1742,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()
+                }
+            });
             external_node_assert_default()(deviceId, 'deviceId is required for AndroidDevice');
             this.deviceId = deviceId;
             this.options = options;
@@ -1849,37 +1842,10 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
                 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: (0, device_namespaceObject.defineAction)({
-                name: 'AndroidBackButton',
-                description: 'Trigger the system "back" operation on Android devices',
-                delayBeforeRunner: 0,
-                delayAfterRunner: 0,
-                call: async ()=>{
-                    await device.back();
-                }
-            }),
-            AndroidHomeButton: (0, device_namespaceObject.defineAction)({
-                name: 'AndroidHomeButton',
-                description: 'Trigger the system "home" operation on Android devices',
-                delayBeforeRunner: 0,
-                delayAfterRunner: 0,
-                call: async ()=>{
-                    await device.home();
-                }
-            }),
-            AndroidRecentAppsButton: (0, device_namespaceObject.defineAction)({
-                name: 'AndroidRecentAppsButton',
-                description: 'Trigger the system "recent apps" operation on Android devices',
-                call: async ()=>{
-                    await device.recentApps();
-                }
             })
         });
     const debugUtils = (0, logger_.getDebug)('android:utils');
@@ -2051,7 +2017,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
         constructor(toolsManager){
             super({
                 name: '@midscene/android-mcp',
-                version: "1.8.0",
+                version: "1.8.1",
                 description: 'Control the Android device using natural language commands'
             }, toolsManager);
         }

package/dist/types/index.d.ts

@@ -13,6 +13,7 @@ import { DeviceAction } from '@midscene/core';
 import type { ElementInfo } from '@midscene/shared/extractor';
 import { InitArgSpec } from '@midscene/shared/mcp/base-tools';
 import { InterfaceType } from '@midscene/core';
+import { MobileInputPrimitives } from '@midscene/core/device';
 import { overrideAIConfig } from '@midscene/shared/env';
 import { Point } from '@midscene/core';
 import { Size } from '@midscene/core';
@@ -95,7 +96,9 @@ export declare class AndroidDevice implements AbstractInterface {
     interfaceType: InterfaceType;
     uri: string | undefined;
     options?: AndroidDeviceOpt;
+    readonly inputPrimitives: MobileInputPrimitives;
     actionSpace(): DeviceAction<any>[];
+    private performActionScroll;
     constructor(deviceId: string, options?: AndroidDeviceOpt);
     describe(): string;
     connect(): Promise<ADB>;
@@ -196,19 +199,14 @@ export declare class AndroidDevice implements AbstractInterface {
      * via escapeForShell + double-quoted shell context.
      */
     private shouldUseYadbForText;
-    keyboardType(text: string, options?: AndroidDeviceInputOpt): Promise<void>;
+    private typeText;
     private normalizeKeyName;
-    keyboardPress(key: string): Promise<void>;
-    mouseClick(x: number, y: number): Promise<void>;
-    mouseDoubleClick(x: number, y: number): Promise<void>;
+    private pressKey;
+    private tapPoint;
+    private doubleTapPoint;
     mouseMove(): Promise<void>;
-    mouseDrag(from: {
-        x: number;
-        y: number;
-    }, to: {
-        x: number;
-        y: number;
-    }, duration?: number): Promise<void>;
+    private dragPoint;
+    private swipePoint;
     scroll(deltaX: number, deltaY: number, duration?: number, warnOnClamp?: boolean, direction?: ScrollDirection): Promise<void>;
     destroy(): Promise<void>;
     /**
@@ -220,7 +218,7 @@ export declare class AndroidDevice implements AbstractInterface {
     back(): Promise<void>;
     home(): Promise<void>;
     recentApps(): Promise<void>;
-    longPress(x: number, y: number, duration?: number): Promise<void>;
+    private longPressPoint;
     pullDown(startPoint?: Point, distance?: number, duration?: number): Promise<void>;
     pullDrag(from: {
         x: number;

package/dist/types/mcp-server.d.ts

@@ -14,6 +14,7 @@ import { InitArgSpec } from '@midscene/shared/mcp/base-tools';
 import { InterfaceType } from '@midscene/core';
 import { LaunchMCPServerOptions } from '@midscene/shared/mcp';
 import { LaunchMCPServerResult } from '@midscene/shared/mcp';
+import { MobileInputPrimitives } from '@midscene/core/device';
 import { Point } from '@midscene/core';
 import { Size } from '@midscene/core';
 import { Tool } from '@midscene/shared/mcp';
@@ -87,7 +88,9 @@ declare class AndroidDevice implements AbstractInterface {
     interfaceType: InterfaceType;
     uri: string | undefined;
     options?: AndroidDeviceOpt;
+    readonly inputPrimitives: MobileInputPrimitives;
     actionSpace(): DeviceAction<any>[];
+    private performActionScroll;
     constructor(deviceId: string, options?: AndroidDeviceOpt);
     describe(): string;
     connect(): Promise<ADB>;
@@ -188,19 +191,14 @@ declare class AndroidDevice implements AbstractInterface {
      * via escapeForShell + double-quoted shell context.
      */
     private shouldUseYadbForText;
-    keyboardType(text: string, options?: AndroidDeviceInputOpt): Promise<void>;
+    private typeText;
     private normalizeKeyName;
-    keyboardPress(key: string): Promise<void>;
-    mouseClick(x: number, y: number): Promise<void>;
-    mouseDoubleClick(x: number, y: number): Promise<void>;
+    private pressKey;
+    private tapPoint;
+    private doubleTapPoint;
     mouseMove(): Promise<void>;
-    mouseDrag(from: {
-        x: number;
-        y: number;
-    }, to: {
-        x: number;
-        y: number;
-    }, duration?: number): Promise<void>;
+    private dragPoint;
+    private swipePoint;
     scroll(deltaX: number, deltaY: number, duration?: number, warnOnClamp?: boolean, direction?: ScrollDirection): Promise<void>;
     destroy(): Promise<void>;
     /**
@@ -212,7 +210,7 @@ declare class AndroidDevice implements AbstractInterface {
     back(): Promise<void>;
     home(): Promise<void>;
     recentApps(): Promise<void>;
-    longPress(x: number, y: number, duration?: number): Promise<void>;
+    private longPressPoint;
     pullDown(startPoint?: Point, distance?: number, duration?: number): Promise<void>;
     pullDrag(from: {
         x: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midscene/android",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "Android automation library for Midscene",
   "keywords": [
     "Android UI automation",
@@ -41,8 +41,8 @@
     "@yume-chan/stream-extra": "2.1.0",
     "appium-adb": "12.12.1",
     "sharp": "^0.34.3",
-    "@midscene/core": "1.8.0",
-    "@midscene/shared": "1.8.0"
+    "@midscene/shared": "1.8.1",
+    "@midscene/core": "1.8.1"
   },
   "optionalDependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0"
@@ -56,7 +56,7 @@
     "undici": "^6.0.0",
     "vitest": "3.0.5",
     "zod": "^3.25.1",
-    "@midscene/playground": "1.8.0"
+    "@midscene/playground": "1.8.1"
   },
   "license": "MIT",
   "scripts": {