@midscene/android 1.8.0 → 1.8.1

package/dist/lib/cli.js

@@ -699,103 +699,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',
@@ -825,19 +752,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));
@@ -848,6 +762,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}`;
         }
@@ -1335,14 +1270,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();
@@ -1363,7 +1304,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;
             }
@@ -1380,7 +1321,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;
             }
@@ -1398,7 +1339,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;
             }
@@ -1415,7 +1356,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;
             }
@@ -1433,7 +1374,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');
@@ -1449,7 +1390,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');
@@ -1465,7 +1406,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');
@@ -1481,7 +1422,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');
@@ -1502,7 +1443,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;
@@ -1539,7 +1480,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,
@@ -1561,14 +1502,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);
@@ -1577,12 +1518,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');
@@ -1605,11 +1548,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;
@@ -1657,9 +1603,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) {
@@ -1680,10 +1626,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();
@@ -1784,6 +1727,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;
@@ -1834,37 +1827,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');
@@ -2031,7 +1997,7 @@ ${Object.keys(size).filter((key)=>size[key]).map((key)=>`  ${key} size: ${size[k
     const tools = new AndroidMidsceneTools();
     (0, cli_namespaceObject.runToolsCLI)(tools, 'midscene-android', {
         stripPrefix: 'android_',
-        version: "1.8.0",
+        version: "1.8.1",
         extraCommands: (0, core_namespaceObject.createReportCliCommands)()
     }).catch((e)=>{
         process.exit((0, cli_namespaceObject.reportCLIError)(e));