@midscene/android 0.13.1 → 0.13.2-beta-20250401015137.0

package/README.md

@@ -0,0 +1,14 @@
+## Android prerequisites
+
+Android is driven by adb, so you need install adb first:
+- [CLI](https://developer.android.com/tools/adb)
+
+```bash
+npm run test:ai -- setting.test.ts
+```
+
+or 
+
+```bash
+npm run test:ai -- todo.test.ts
+```

package/dist/es/index.d.ts

@@ -1 +1,81 @@
-export { AndroidAgent, AndroidPage } from '@midscene/web/android';
+import { AbstractPage } from '@midscene/web';
+export { PageAgent as AndroidAgent } from '@midscene/web';
+import { Size, Point } from '@midscene/core';
+import { ElementInfo } from '@midscene/shared/extractor';
+import { ADB } from 'appium-adb';
+
+declare class Page implements AbstractPage {
+    private deviceId;
+    private screenSize;
+    private yadbPushed;
+    private deviceRatio;
+    private adbInitPromise;
+    pageType: string;
+    constructor({ deviceId }: {
+        deviceId: string;
+    });
+    private initAdb;
+    getAdb(): Promise<ADB>;
+    private execYadb;
+    getElementsInfo(): Promise<ElementInfo[]>;
+    getElementsNodeTree(): Promise<any>;
+    size(): Promise<Size>;
+    /**
+     * Convert logical coordinates to physical coordinates, handling device ratio
+     * @param x Logical X coordinate
+     * @param y Logical Y coordinate
+     * @returns Physical coordinate point
+     */
+    private adjustCoordinates;
+    /**
+     * Convert physical coordinates to logical coordinates, handling device ratio
+     * @param x Physical X coordinate
+     * @param y Physical Y coordinate
+     * @returns Logical coordinate point
+     */
+    private reverseAdjustCoordinates;
+    screenshotBase64(): Promise<string>;
+    get mouse(): {
+        click: (x: number, y: number) => Promise<void>;
+        wheel: (deltaX: number, deltaY: number) => Promise<void>;
+        move: (x: number, y: number) => Promise<void>;
+        drag: (from: {
+            x: number;
+            y: number;
+        }, to: {
+            x: number;
+            y: number;
+        }) => Promise<void>;
+    };
+    get keyboard(): {
+        type: (text: string) => Promise<void>;
+        press: (action: {
+            key: string;
+            command?: string;
+        } | {
+            key: string;
+            command?: string;
+        }[]) => Promise<void>;
+    };
+    clearInput(element: ElementInfo): Promise<void>;
+    url(): Promise<string>;
+    scrollUntilTop(startingPoint?: Point): Promise<void>;
+    scrollUntilBottom(startingPoint?: Point): Promise<void>;
+    scrollUntilLeft(startingPoint?: Point): Promise<void>;
+    scrollUntilRight(startingPoint?: Point): Promise<void>;
+    scrollUp(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollDown(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollLeft(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollRight(distance?: number, startingPoint?: Point): Promise<void>;
+    private pushYadb;
+    private keyboardType;
+    private keyboardPress;
+    private keyboardPressAction;
+    private mouseClick;
+    private mouseMove;
+    private mouseDrag;
+    private mouseWheel;
+    destroy(): Promise<void>;
+}
+
+export { Page as AndroidPage };

package/dist/es/index.js

@@ -1,6 +1,329 @@
 // src/index.ts
-import { AndroidAgent, AndroidPage } from "@midscene/web/android";
+import { PageAgent } from "@midscene/web";
+
+// src/page/index.ts
+import fs from "fs";
+import path from "path";
+import { getTmpFile } from "@midscene/core/utils";
+import { resizeImg } from "@midscene/shared/img";
+import { getDebug } from "@midscene/shared/logger";
+import { ADB } from "appium-adb";
+var debugPage = getDebug("android");
+var Page = class {
+  constructor({ deviceId }) {
+    this.screenSize = null;
+    this.yadbPushed = false;
+    this.deviceRatio = 1;
+    this.pageType = "android";
+    this.deviceId = deviceId;
+    this.adbInitPromise = this.initAdb();
+  }
+  async initAdb() {
+    debugPage(`Initializing ADB with device ID: ${this.deviceId}`);
+    const adb = await ADB.createADB({
+      udid: this.deviceId,
+      adbExecTimeout: 6e4
+    });
+    debugPage("ADB initialized successfully");
+    return adb;
+  }
+  async getAdb() {
+    return this.adbInitPromise;
+  }
+  async execYadb(keyboardContent) {
+    await this.pushYadb();
+    const adb = await this.getAdb();
+    await adb.shell(
+      `app_process -Djava.class.path=/data/local/tmp/yadb /data/local/tmp com.ysbing.yadb.Main -keyboard "${keyboardContent}"`
+    );
+  }
+  async getElementsInfo() {
+    return [];
+  }
+  async getElementsNodeTree() {
+    return {
+      node: null,
+      children: []
+    };
+  }
+  async size() {
+    if (this.screenSize) {
+      return this.screenSize;
+    }
+    const adb = await this.getAdb();
+    const screenSize = await adb.getScreenSize();
+    let width;
+    let height;
+    if (typeof screenSize === "string") {
+      const match = screenSize.match(/(\d+)x(\d+)/);
+      if (!match || match.length < 3) {
+        throw new Error(`Unable to parse screen size: ${screenSize}`);
+      }
+      width = Number.parseInt(match[1], 10);
+      height = Number.parseInt(match[2], 10);
+    } else if (typeof screenSize === "object" && screenSize !== null) {
+      const sizeObj = screenSize;
+      if ("width" in sizeObj && "height" in sizeObj) {
+        width = Number(sizeObj.width);
+        height = Number(sizeObj.height);
+      } else {
+        throw new Error(
+          `Invalid screen size object: ${JSON.stringify(screenSize)}`
+        );
+      }
+    } else {
+      throw new Error(`Invalid screen size format: ${screenSize}`);
+    }
+    const densityNum = await adb.getScreenDensity();
+    this.deviceRatio = Number(densityNum) / 160;
+    const { x: logicalWidth, y: logicalHeight } = this.reverseAdjustCoordinates(
+      width,
+      height
+    );
+    this.screenSize = {
+      width: logicalWidth,
+      height: logicalHeight
+    };
+    return this.screenSize;
+  }
+  /**
+   * Convert logical coordinates to physical coordinates, handling device ratio
+   * @param x Logical X coordinate
+   * @param y Logical Y coordinate
+   * @returns Physical coordinate point
+   */
+  adjustCoordinates(x, y) {
+    const ratio = this.deviceRatio;
+    return {
+      x: Math.round(x * ratio),
+      y: Math.round(y * ratio)
+    };
+  }
+  /**
+   * Convert physical coordinates to logical coordinates, handling device ratio
+   * @param x Physical X coordinate
+   * @param y Physical Y coordinate
+   * @returns Logical coordinate point
+   */
+  reverseAdjustCoordinates(x, y) {
+    const ratio = this.deviceRatio;
+    return {
+      x: Math.round(x / ratio),
+      y: Math.round(y / ratio)
+    };
+  }
+  async screenshotBase64() {
+    debugPage("screenshotBase64 begin");
+    const { width, height } = await this.size();
+    const adb = await this.getAdb();
+    let screenshotBuffer;
+    try {
+      screenshotBuffer = await adb.takeScreenshot(null);
+    } catch (error) {
+      const screenshotPath = getTmpFile("png");
+      await adb.shell("screencap -p /sdcard/screenshot.png");
+      await adb.pull("/sdcard/screenshot.png", screenshotPath);
+      screenshotBuffer = await fs.promises.readFile(screenshotPath);
+    }
+    const resizedScreenshotBuffer = await resizeImg(screenshotBuffer, {
+      width,
+      height
+    });
+    const result = `data:image/jpeg;base64,${resizedScreenshotBuffer.toString("base64")}`;
+    debugPage("screenshotBase64 end");
+    return result;
+  }
+  get mouse() {
+    return {
+      click: (x, y) => this.mouseClick(x, y),
+      wheel: (deltaX, deltaY) => this.mouseWheel(deltaX, deltaY),
+      move: (x, y) => this.mouseMove(x, y),
+      drag: (from, to) => this.mouseDrag(from, to)
+    };
+  }
+  get keyboard() {
+    return {
+      type: (text) => this.keyboardType(text),
+      press: (action) => this.keyboardPressAction(action)
+    };
+  }
+  async clearInput(element) {
+    if (!element) {
+      return;
+    }
+    await this.pushYadb();
+    const adb = await this.getAdb();
+    await adb.shell(
+      'app_process -Djava.class.path=/data/local/tmp/yadb /data/local/tmp com.ysbing.yadb.Main -keyboard "~CLEAR~"'
+    );
+  }
+  async url() {
+    const adb = await this.getAdb();
+    const { appPackage, appActivity } = await adb.getFocusedPackageAndActivity();
+    return `${appPackage}/${appActivity}`;
+  }
+  async scrollUntilTop(startingPoint) {
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(0, 9999999, 100);
+  }
+  async scrollUntilBottom(startingPoint) {
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(0, -9999999, 100);
+  }
+  async scrollUntilLeft(startingPoint) {
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(9999999, 0, 100);
+  }
+  async scrollUntilRight(startingPoint) {
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(-9999999, 0, 100);
+  }
+  async scrollUp(distance, startingPoint) {
+    const { height } = await this.size();
+    const scrollDistance = distance || height * 0.7;
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(0, scrollDistance, 1e3);
+  }
+  async scrollDown(distance, startingPoint) {
+    const { height } = await this.size();
+    const scrollDistance = distance || height * 0.7;
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(0, -scrollDistance, 1e3);
+  }
+  async scrollLeft(distance, startingPoint) {
+    const { width } = await this.size();
+    const scrollDistance = distance || width * 0.7;
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(scrollDistance, 0, 1e3);
+  }
+  async scrollRight(distance, startingPoint) {
+    const { width } = await this.size();
+    const scrollDistance = distance || width * 0.7;
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(-scrollDistance, 0, 1e3);
+  }
+  async pushYadb() {
+    if (!this.yadbPushed) {
+      const adb = await this.getAdb();
+      const yadbBin = path.join(__dirname, "../../bin/yadb");
+      await adb.push(yadbBin, "/data/local/tmp");
+      this.yadbPushed = true;
+    }
+  }
+  async keyboardType(text) {
+    if (!text)
+      return;
+    const adb = await this.getAdb();
+    const isChinese = /[\p{Script=Han}\p{sc=Hani}]/u.test(text);
+    if (!isChinese) {
+      await adb.inputText(text);
+      return;
+    }
+    await this.execYadb(text);
+  }
+  async keyboardPress(key) {
+    const keyCodeMap = {
+      Enter: 66,
+      Backspace: 67,
+      Tab: 61,
+      ArrowUp: 19,
+      ArrowDown: 20,
+      ArrowLeft: 21,
+      ArrowRight: 22,
+      Escape: 111,
+      Home: 3,
+      End: 123
+    };
+    const adb = await this.getAdb();
+    const keyCode = keyCodeMap[key];
+    if (keyCode !== void 0) {
+      await adb.keyevent(keyCode);
+    } else {
+      if (key.length === 1) {
+        const asciiCode = key.toUpperCase().charCodeAt(0);
+        if (asciiCode >= 65 && asciiCode <= 90) {
+          await adb.keyevent(asciiCode - 36);
+        }
+      }
+    }
+  }
+  async keyboardPressAction(action) {
+    if (Array.isArray(action)) {
+      for (const act of action) {
+        await this.keyboardPress(act.key);
+      }
+    } else {
+      await this.keyboardPress(action.key);
+    }
+  }
+  async mouseClick(x, y) {
+    await this.mouseMove(x, y);
+    const adb = await this.getAdb();
+    const { x: adjustedX, y: adjustedY } = this.adjustCoordinates(x, y);
+    await adb.shell(`input tap ${adjustedX} ${adjustedY}`);
+  }
+  async mouseMove(x, y) {
+    return Promise.resolve();
+  }
+  async mouseDrag(from, to) {
+    const adb = await this.getAdb();
+    const { x: fromX, y: fromY } = this.adjustCoordinates(from.x, from.y);
+    const { x: toX, y: toY } = this.adjustCoordinates(to.x, to.y);
+    await adb.shell(`input swipe ${fromX} ${fromY} ${toX} ${toY} 300`);
+  }
+  async mouseWheel(deltaX, deltaY, duration = 1e3) {
+    const { width, height } = await this.size();
+    const n = 4;
+    const startX = deltaX < 0 ? (n - 1) * (width / n) : width / n;
+    const startY = deltaY < 0 ? (n - 1) * (height / n) : height / n;
+    const maxNegativeDeltaX = startX;
+    const maxPositiveDeltaX = (n - 1) * (width / n);
+    const maxNegativeDeltaY = startY;
+    const maxPositiveDeltaY = (n - 1) * (height / n);
+    deltaX = Math.max(-maxNegativeDeltaX, Math.min(deltaX, maxPositiveDeltaX));
+    deltaY = Math.max(-maxNegativeDeltaY, Math.min(deltaY, maxPositiveDeltaY));
+    const endX = startX + deltaX;
+    const endY = startY + deltaY;
+    const { x: adjustedStartX, y: adjustedStartY } = this.adjustCoordinates(
+      startX,
+      startY
+    );
+    const { x: adjustedEndX, y: adjustedEndY } = this.adjustCoordinates(
+      endX,
+      endY
+    );
+    const adb = await this.getAdb();
+    await adb.shell(
+      `input swipe ${adjustedStartX} ${adjustedStartY} ${adjustedEndX} ${adjustedEndY} ${duration}`
+    );
+  }
+  async destroy() {
+    try {
+      const adb = await this.getAdb();
+      await adb.shell("rm -f /sdcard/screenshot.png");
+      await adb.shell("rm -f /sdcard/window_dump.xml");
+    } catch (error) {
+      console.error("Error during cleanup:", error);
+    }
+  }
+};
 export {
-  AndroidAgent,
-  AndroidPage
+  PageAgent as AndroidAgent,
+  Page as AndroidPage
 };

package/dist/lib/index.d.ts

@@ -1 +1,81 @@
-export { AndroidAgent, AndroidPage } from '@midscene/web/android';
+import { AbstractPage } from '@midscene/web';
+export { PageAgent as AndroidAgent } from '@midscene/web';
+import { Size, Point } from '@midscene/core';
+import { ElementInfo } from '@midscene/shared/extractor';
+import { ADB } from 'appium-adb';
+
+declare class Page implements AbstractPage {
+    private deviceId;
+    private screenSize;
+    private yadbPushed;
+    private deviceRatio;
+    private adbInitPromise;
+    pageType: string;
+    constructor({ deviceId }: {
+        deviceId: string;
+    });
+    private initAdb;
+    getAdb(): Promise<ADB>;
+    private execYadb;
+    getElementsInfo(): Promise<ElementInfo[]>;
+    getElementsNodeTree(): Promise<any>;
+    size(): Promise<Size>;
+    /**
+     * Convert logical coordinates to physical coordinates, handling device ratio
+     * @param x Logical X coordinate
+     * @param y Logical Y coordinate
+     * @returns Physical coordinate point
+     */
+    private adjustCoordinates;
+    /**
+     * Convert physical coordinates to logical coordinates, handling device ratio
+     * @param x Physical X coordinate
+     * @param y Physical Y coordinate
+     * @returns Logical coordinate point
+     */
+    private reverseAdjustCoordinates;
+    screenshotBase64(): Promise<string>;
+    get mouse(): {
+        click: (x: number, y: number) => Promise<void>;
+        wheel: (deltaX: number, deltaY: number) => Promise<void>;
+        move: (x: number, y: number) => Promise<void>;
+        drag: (from: {
+            x: number;
+            y: number;
+        }, to: {
+            x: number;
+            y: number;
+        }) => Promise<void>;
+    };
+    get keyboard(): {
+        type: (text: string) => Promise<void>;
+        press: (action: {
+            key: string;
+            command?: string;
+        } | {
+            key: string;
+            command?: string;
+        }[]) => Promise<void>;
+    };
+    clearInput(element: ElementInfo): Promise<void>;
+    url(): Promise<string>;
+    scrollUntilTop(startingPoint?: Point): Promise<void>;
+    scrollUntilBottom(startingPoint?: Point): Promise<void>;
+    scrollUntilLeft(startingPoint?: Point): Promise<void>;
+    scrollUntilRight(startingPoint?: Point): Promise<void>;
+    scrollUp(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollDown(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollLeft(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollRight(distance?: number, startingPoint?: Point): Promise<void>;
+    private pushYadb;
+    private keyboardType;
+    private keyboardPress;
+    private keyboardPressAction;
+    private mouseClick;
+    private mouseMove;
+    private mouseDrag;
+    private mouseWheel;
+    destroy(): Promise<void>;
+}
+
+export { Page as AndroidPage };

package/dist/lib/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,16 +17,347 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  AndroidAgent: () => import_android.AndroidAgent,
-  AndroidPage: () => import_android.AndroidPage
+  AndroidAgent: () => import_web.PageAgent,
+  AndroidPage: () => Page
 });
 module.exports = __toCommonJS(src_exports);
-var import_android = require("@midscene/web/android");
+var import_web = require("@midscene/web");
+
+// src/page/index.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+var import_utils = require("@midscene/core/utils");
+var import_img = require("@midscene/shared/img");
+var import_logger = require("@midscene/shared/logger");
+var import_appium_adb = require("appium-adb");
+var debugPage = (0, import_logger.getDebug)("android");
+var Page = class {
+  constructor({ deviceId }) {
+    this.screenSize = null;
+    this.yadbPushed = false;
+    this.deviceRatio = 1;
+    this.pageType = "android";
+    this.deviceId = deviceId;
+    this.adbInitPromise = this.initAdb();
+  }
+  async initAdb() {
+    debugPage(`Initializing ADB with device ID: ${this.deviceId}`);
+    const adb = await import_appium_adb.ADB.createADB({
+      udid: this.deviceId,
+      adbExecTimeout: 6e4
+    });
+    debugPage("ADB initialized successfully");
+    return adb;
+  }
+  async getAdb() {
+    return this.adbInitPromise;
+  }
+  async execYadb(keyboardContent) {
+    await this.pushYadb();
+    const adb = await this.getAdb();
+    await adb.shell(
+      `app_process -Djava.class.path=/data/local/tmp/yadb /data/local/tmp com.ysbing.yadb.Main -keyboard "${keyboardContent}"`
+    );
+  }
+  async getElementsInfo() {
+    return [];
+  }
+  async getElementsNodeTree() {
+    return {
+      node: null,
+      children: []
+    };
+  }
+  async size() {
+    if (this.screenSize) {
+      return this.screenSize;
+    }
+    const adb = await this.getAdb();
+    const screenSize = await adb.getScreenSize();
+    let width;
+    let height;
+    if (typeof screenSize === "string") {
+      const match = screenSize.match(/(\d+)x(\d+)/);
+      if (!match || match.length < 3) {
+        throw new Error(`Unable to parse screen size: ${screenSize}`);
+      }
+      width = Number.parseInt(match[1], 10);
+      height = Number.parseInt(match[2], 10);
+    } else if (typeof screenSize === "object" && screenSize !== null) {
+      const sizeObj = screenSize;
+      if ("width" in sizeObj && "height" in sizeObj) {
+        width = Number(sizeObj.width);
+        height = Number(sizeObj.height);
+      } else {
+        throw new Error(
+          `Invalid screen size object: ${JSON.stringify(screenSize)}`
+        );
+      }
+    } else {
+      throw new Error(`Invalid screen size format: ${screenSize}`);
+    }
+    const densityNum = await adb.getScreenDensity();
+    this.deviceRatio = Number(densityNum) / 160;
+    const { x: logicalWidth, y: logicalHeight } = this.reverseAdjustCoordinates(
+      width,
+      height
+    );
+    this.screenSize = {
+      width: logicalWidth,
+      height: logicalHeight
+    };
+    return this.screenSize;
+  }
+  /**
+   * Convert logical coordinates to physical coordinates, handling device ratio
+   * @param x Logical X coordinate
+   * @param y Logical Y coordinate
+   * @returns Physical coordinate point
+   */
+  adjustCoordinates(x, y) {
+    const ratio = this.deviceRatio;
+    return {
+      x: Math.round(x * ratio),
+      y: Math.round(y * ratio)
+    };
+  }
+  /**
+   * Convert physical coordinates to logical coordinates, handling device ratio
+   * @param x Physical X coordinate
+   * @param y Physical Y coordinate
+   * @returns Logical coordinate point
+   */
+  reverseAdjustCoordinates(x, y) {
+    const ratio = this.deviceRatio;
+    return {
+      x: Math.round(x / ratio),
+      y: Math.round(y / ratio)
+    };
+  }
+  async screenshotBase64() {
+    debugPage("screenshotBase64 begin");
+    const { width, height } = await this.size();
+    const adb = await this.getAdb();
+    let screenshotBuffer;
+    try {
+      screenshotBuffer = await adb.takeScreenshot(null);
+    } catch (error) {
+      const screenshotPath = (0, import_utils.getTmpFile)("png");
+      await adb.shell("screencap -p /sdcard/screenshot.png");
+      await adb.pull("/sdcard/screenshot.png", screenshotPath);
+      screenshotBuffer = await import_node_fs.default.promises.readFile(screenshotPath);
+    }
+    const resizedScreenshotBuffer = await (0, import_img.resizeImg)(screenshotBuffer, {
+      width,
+      height
+    });
+    const result = `data:image/jpeg;base64,${resizedScreenshotBuffer.toString("base64")}`;
+    debugPage("screenshotBase64 end");
+    return result;
+  }
+  get mouse() {
+    return {
+      click: (x, y) => this.mouseClick(x, y),
+      wheel: (deltaX, deltaY) => this.mouseWheel(deltaX, deltaY),
+      move: (x, y) => this.mouseMove(x, y),
+      drag: (from, to) => this.mouseDrag(from, to)
+    };
+  }
+  get keyboard() {
+    return {
+      type: (text) => this.keyboardType(text),
+      press: (action) => this.keyboardPressAction(action)
+    };
+  }
+  async clearInput(element) {
+    if (!element) {
+      return;
+    }
+    await this.pushYadb();
+    const adb = await this.getAdb();
+    await adb.shell(
+      'app_process -Djava.class.path=/data/local/tmp/yadb /data/local/tmp com.ysbing.yadb.Main -keyboard "~CLEAR~"'
+    );
+  }
+  async url() {
+    const adb = await this.getAdb();
+    const { appPackage, appActivity } = await adb.getFocusedPackageAndActivity();
+    return `${appPackage}/${appActivity}`;
+  }
+  async scrollUntilTop(startingPoint) {
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(0, 9999999, 100);
+  }
+  async scrollUntilBottom(startingPoint) {
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(0, -9999999, 100);
+  }
+  async scrollUntilLeft(startingPoint) {
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(9999999, 0, 100);
+  }
+  async scrollUntilRight(startingPoint) {
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(-9999999, 0, 100);
+  }
+  async scrollUp(distance, startingPoint) {
+    const { height } = await this.size();
+    const scrollDistance = distance || height * 0.7;
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(0, scrollDistance, 1e3);
+  }
+  async scrollDown(distance, startingPoint) {
+    const { height } = await this.size();
+    const scrollDistance = distance || height * 0.7;
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(0, -scrollDistance, 1e3);
+  }
+  async scrollLeft(distance, startingPoint) {
+    const { width } = await this.size();
+    const scrollDistance = distance || width * 0.7;
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(scrollDistance, 0, 1e3);
+  }
+  async scrollRight(distance, startingPoint) {
+    const { width } = await this.size();
+    const scrollDistance = distance || width * 0.7;
+    if (startingPoint) {
+      await this.mouse.move(startingPoint.left, startingPoint.top);
+    }
+    await this.mouseWheel(-scrollDistance, 0, 1e3);
+  }
+  async pushYadb() {
+    if (!this.yadbPushed) {
+      const adb = await this.getAdb();
+      const yadbBin = import_node_path.default.join(__dirname, "../../bin/yadb");
+      await adb.push(yadbBin, "/data/local/tmp");
+      this.yadbPushed = true;
+    }
+  }
+  async keyboardType(text) {
+    if (!text)
+      return;
+    const adb = await this.getAdb();
+    const isChinese = /[\p{Script=Han}\p{sc=Hani}]/u.test(text);
+    if (!isChinese) {
+      await adb.inputText(text);
+      return;
+    }
+    await this.execYadb(text);
+  }
+  async keyboardPress(key) {
+    const keyCodeMap = {
+      Enter: 66,
+      Backspace: 67,
+      Tab: 61,
+      ArrowUp: 19,
+      ArrowDown: 20,
+      ArrowLeft: 21,
+      ArrowRight: 22,
+      Escape: 111,
+      Home: 3,
+      End: 123
+    };
+    const adb = await this.getAdb();
+    const keyCode = keyCodeMap[key];
+    if (keyCode !== void 0) {
+      await adb.keyevent(keyCode);
+    } else {
+      if (key.length === 1) {
+        const asciiCode = key.toUpperCase().charCodeAt(0);
+        if (asciiCode >= 65 && asciiCode <= 90) {
+          await adb.keyevent(asciiCode - 36);
+        }
+      }
+    }
+  }
+  async keyboardPressAction(action) {
+    if (Array.isArray(action)) {
+      for (const act of action) {
+        await this.keyboardPress(act.key);
+      }
+    } else {
+      await this.keyboardPress(action.key);
+    }
+  }
+  async mouseClick(x, y) {
+    await this.mouseMove(x, y);
+    const adb = await this.getAdb();
+    const { x: adjustedX, y: adjustedY } = this.adjustCoordinates(x, y);
+    await adb.shell(`input tap ${adjustedX} ${adjustedY}`);
+  }
+  async mouseMove(x, y) {
+    return Promise.resolve();
+  }
+  async mouseDrag(from, to) {
+    const adb = await this.getAdb();
+    const { x: fromX, y: fromY } = this.adjustCoordinates(from.x, from.y);
+    const { x: toX, y: toY } = this.adjustCoordinates(to.x, to.y);
+    await adb.shell(`input swipe ${fromX} ${fromY} ${toX} ${toY} 300`);
+  }
+  async mouseWheel(deltaX, deltaY, duration = 1e3) {
+    const { width, height } = await this.size();
+    const n = 4;
+    const startX = deltaX < 0 ? (n - 1) * (width / n) : width / n;
+    const startY = deltaY < 0 ? (n - 1) * (height / n) : height / n;
+    const maxNegativeDeltaX = startX;
+    const maxPositiveDeltaX = (n - 1) * (width / n);
+    const maxNegativeDeltaY = startY;
+    const maxPositiveDeltaY = (n - 1) * (height / n);
+    deltaX = Math.max(-maxNegativeDeltaX, Math.min(deltaX, maxPositiveDeltaX));
+    deltaY = Math.max(-maxNegativeDeltaY, Math.min(deltaY, maxPositiveDeltaY));
+    const endX = startX + deltaX;
+    const endY = startY + deltaY;
+    const { x: adjustedStartX, y: adjustedStartY } = this.adjustCoordinates(
+      startX,
+      startY
+    );
+    const { x: adjustedEndX, y: adjustedEndY } = this.adjustCoordinates(
+      endX,
+      endY
+    );
+    const adb = await this.getAdb();
+    await adb.shell(
+      `input swipe ${adjustedStartX} ${adjustedStartY} ${adjustedEndX} ${adjustedEndY} ${duration}`
+    );
+  }
+  async destroy() {
+    try {
+      const adb = await this.getAdb();
+      await adb.shell("rm -f /sdcard/screenshot.png");
+      await adb.shell("rm -f /sdcard/window_dump.xml");
+    } catch (error) {
+      console.error("Error during cleanup:", error);
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AndroidAgent,

package/dist/types/index.d.ts

@@ -1 +1,81 @@
-export { AndroidAgent, AndroidPage } from '@midscene/web/android';
+import { AbstractPage } from '@midscene/web';
+export { PageAgent as AndroidAgent } from '@midscene/web';
+import { Size, Point } from '@midscene/core';
+import { ElementInfo } from '@midscene/shared/extractor';
+import { ADB } from 'appium-adb';
+
+declare class Page implements AbstractPage {
+    private deviceId;
+    private screenSize;
+    private yadbPushed;
+    private deviceRatio;
+    private adbInitPromise;
+    pageType: string;
+    constructor({ deviceId }: {
+        deviceId: string;
+    });
+    private initAdb;
+    getAdb(): Promise<ADB>;
+    private execYadb;
+    getElementsInfo(): Promise<ElementInfo[]>;
+    getElementsNodeTree(): Promise<any>;
+    size(): Promise<Size>;
+    /**
+     * Convert logical coordinates to physical coordinates, handling device ratio
+     * @param x Logical X coordinate
+     * @param y Logical Y coordinate
+     * @returns Physical coordinate point
+     */
+    private adjustCoordinates;
+    /**
+     * Convert physical coordinates to logical coordinates, handling device ratio
+     * @param x Physical X coordinate
+     * @param y Physical Y coordinate
+     * @returns Logical coordinate point
+     */
+    private reverseAdjustCoordinates;
+    screenshotBase64(): Promise<string>;
+    get mouse(): {
+        click: (x: number, y: number) => Promise<void>;
+        wheel: (deltaX: number, deltaY: number) => Promise<void>;
+        move: (x: number, y: number) => Promise<void>;
+        drag: (from: {
+            x: number;
+            y: number;
+        }, to: {
+            x: number;
+            y: number;
+        }) => Promise<void>;
+    };
+    get keyboard(): {
+        type: (text: string) => Promise<void>;
+        press: (action: {
+            key: string;
+            command?: string;
+        } | {
+            key: string;
+            command?: string;
+        }[]) => Promise<void>;
+    };
+    clearInput(element: ElementInfo): Promise<void>;
+    url(): Promise<string>;
+    scrollUntilTop(startingPoint?: Point): Promise<void>;
+    scrollUntilBottom(startingPoint?: Point): Promise<void>;
+    scrollUntilLeft(startingPoint?: Point): Promise<void>;
+    scrollUntilRight(startingPoint?: Point): Promise<void>;
+    scrollUp(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollDown(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollLeft(distance?: number, startingPoint?: Point): Promise<void>;
+    scrollRight(distance?: number, startingPoint?: Point): Promise<void>;
+    private pushYadb;
+    private keyboardType;
+    private keyboardPress;
+    private keyboardPressAction;
+    private mouseClick;
+    private mouseMove;
+    private mouseDrag;
+    private mouseWheel;
+    destroy(): Promise<void>;
+}
+
+export { Page as AndroidPage };

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@midscene/android",
-  "version": "0.13.1",
+  "version": "0.13.2-beta-20250401015137.0",
+  "description": "Android automation library for Midscene",
   "main": "./dist/lib/index.js",
   "types": "./dist/types/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "bin",
+    "README.md"
   ],
   "exports": {
     ".": {
@@ -13,17 +16,23 @@
     }
   },
   "dependencies": {
-    "@midscene/web": "0.13.1"
+    "appium-adb": "12.12.1",
+    "@midscene/web": "0.13.2-beta-20250401015137.0",
+    "@midscene/core": "0.13.2-beta-20250401015137.0",
+    "@midscene/shared": "0.13.2-beta-20250401015137.0"
   },
   "devDependencies": {
     "@modern-js/module-tools": "2.60.6",
     "@types/node": "^18.0.0",
-    "typescript": "^5.8.2"
+    "dotenv": "16.4.5",
+    "typescript": "^5.8.2",
+    "vitest": "3.0.5"
   },
-  "author": "",
-  "license": "ISC",
-  "description": "",
+  "license": "MIT",
   "scripts": {
-    "build": "modern build -c ./modern.config.ts"
+    "build": "modern build -c ./modern.config.ts",
+    "test": "vitest --run",
+    "test:u": "vitest --run -u",
+    "test:ai": "MIDSCENE_CACHE=true npm run test"
   }
 }