assistsx-js 0.2.3 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "assistsx-js",
-    "version": "0.2.3",
+    "version": "0.2.4",
     "description": "assistsx-js自动化开发SDK",
     "main": "dist/index.cjs",
     "module": "dist/index.js",

package/src/assistsx-async.ts

@@ -8,6 +8,7 @@ import { CallResponse } from "./call-response";
 import { Bounds } from "./bounds";
 import { generateUUID } from "./utils";
 import { AppInfo } from "./app-info";
+import { PluginInfo } from "./plugin-info";
 import { DeviceInfo } from "./device-info";
 import type { NodeLookupScope } from "./node-lookup-scope";
 import {
@@ -15,6 +16,7 @@ import {
     callbacks,
     WebFloatingWindowOptions,
 } from "./assistsx";
+import { WindowFlags } from "./window-flags";
 
 /**
  * 截图识别位置信息
@@ -142,6 +144,21 @@ export class AssistsXAsync {
         });
         return response.getDataOrDefault(false);
     }
+
+    /**
+     * 设置悬浮窗可获取焦点（WebView 内输入框 focus 时调用）
+     */
+    public static async setOverlayInputFocus(timeout?: number): Promise<boolean> {
+        return this.setOverlayFlagList(WindowFlags.getOverlayInputFocusFlagList(), timeout);
+    }
+
+    /**
+     * 取消悬浮窗焦点（WebView 内输入框 blur 时调用）
+     */
+    public static async clearOverlayInputFocus(timeout?: number): Promise<boolean> {
+        return this.setOverlayFlagList(WindowFlags.getOverlayInputBlurFlagList(), timeout);
+    }
+
     /**
      * 获取所有符合条件的节点
      * @param filterClass 类名过滤
@@ -1169,6 +1186,22 @@ export class AssistsXAsync {
         });
         return AppInfo.fromJSON(response.getDataOrDefault({}));
     }
+    /**
+     * 获取当前运行的 AssistsX 插件信息（仅 AssistsX 宿主有效，否则返回 null）
+     */
+    public static async getCurrentPlugin(timeout?: number): Promise<PluginInfo | null> {
+        const response = await this.asyncCall(CallMethod.getCurrentPlugin, {
+            timeout,
+        });
+        if (!response.isSuccess()) {
+            return null;
+        }
+        const data = response.getDataOrNull();
+        if (!data) {
+            return null;
+        }
+        return PluginInfo.fromJSON(data);
+    }
     public static async getUniqueDeviceId(timeout?: number): Promise<any> {
         const response = await this.asyncCall(CallMethod.getUniqueDeviceId, {
             timeout,

package/src/assistsx.ts

@@ -9,8 +9,10 @@ import { Bounds } from "./bounds";
 import { decodeBase64UTF8, generateUUID } from "./utils";
 import { AccessibilityEventFilter } from "./accessibility-event-filter";
 import { AppInfo } from "./app-info";
+import { PluginInfo } from "./plugin-info";
 import { DeviceInfo } from "./device-info";
 import type { NodeLookupScope } from "./node-lookup-scope";
+import { WindowFlags } from "./window-flags";
 
 /**
  * 无障碍事件数据结构
@@ -234,6 +236,23 @@ export class AssistsX {
         });
         return response.getDataOrDefault(false);
     }
+
+    /**
+     * 设置悬浮窗可获取焦点（WebView 内输入框 focus 时调用）
+     * @returns 是否设置成功
+     */
+    public static setOverlayInputFocus(): boolean {
+        return this.setOverlayFlagList(WindowFlags.getOverlayInputFocusFlagList());
+    }
+
+    /**
+     * 取消悬浮窗焦点（WebView 内输入框 blur 时调用）
+     * @returns 是否设置成功
+     */
+    public static clearOverlayInputFocus(): boolean {
+        return this.setOverlayFlagList(WindowFlags.getOverlayInputBlurFlagList());
+    }
+
     /**
      * 获取所有符合条件的节点
      * @param filterClass 类名过滤
@@ -1022,6 +1041,20 @@ export class AssistsX {
         });
         return AppInfo.fromJSON(response.getDataOrDefault({}));
     }
+    /**
+     * 获取当前运行的 AssistsX 插件信息（仅 AssistsX 宿主有效，否则返回 null）
+     */
+    public static getCurrentPlugin(): PluginInfo | null {
+        const response = this.call(CallMethod.getCurrentPlugin);
+        if (!response.isSuccess()) {
+            return null;
+        }
+        const data = response.getDataOrNull();
+        if (!data) {
+            return null;
+        }
+        return PluginInfo.fromJSON(data);
+    }
     public static getUniqueDeviceId(): any {
         const response = this.call(CallMethod.getUniqueDeviceId);
         return response.getDataOrDefault("");

package/src/call-method.ts

@@ -46,6 +46,7 @@ export const CallMethod = {
     longPressGestureAutoPaste: "longPressGestureAutoPaste",
 
     getAppInfo: "getAppInfo",
+    getCurrentPlugin: "getCurrentPlugin",
     getMacAddress: "getMacAddress",
     getAndroidID: "getAndroidID",
     getUniqueDeviceId: "getUniqueDeviceId",

package/src/db/db-call-method.ts

@@ -0,0 +1,11 @@
+/**
+ * SQLite 数据库桥接方法名常量
+ */
+export const DbCallMethod = {
+    exec: "exec",
+    query: "query",
+    execBatch: "execBatch",
+    close: "close",
+} as const;
+
+export type DbCallMethodType = (typeof DbCallMethod)[keyof typeof DbCallMethod];

package/src/db/db.ts

@@ -0,0 +1,254 @@
+/**
+ * SQLite 数据库 Bridge：assistsxDb
+ */
+import { CallResponse } from "../call-response";
+import { decodeBase64UTF8, generateUUID } from "../utils";
+import { DbCallMethod } from "./db-call-method";
+
+/** 数据库定位；dbPath 与 dbName 均可选，均未传时默认 default.db */
+export interface DbTarget {
+    dbPath?: string;
+    dbName?: string;
+}
+
+/** exec 成功返回 */
+export interface DbExecResult {
+    rowsAffected: number;
+    lastInsertRowId: number;
+}
+
+/** query 单行记录；BLOB 字段为 Base64 字符串 */
+export type DbRow = Record<string, string | number | null>;
+
+/** query 成功返回 */
+export interface DbQueryResult {
+    columns: string[];
+    rows: DbRow[];
+    rowCount: number;
+}
+
+/** execBatch 单条结果 */
+export interface DbBatchItemResult {
+    rowsAffected: number;
+    lastInsertRowId: number;
+}
+
+/** execBatch 成功返回 */
+export interface DbExecBatchResult {
+    count: number;
+    results: DbBatchItemResult[];
+}
+
+/** 公共调用选项 */
+export interface DbCallOptions extends DbTarget {
+    bindArgs?: (string | number | boolean | null)[];
+    /** 超时时间（秒），默认 30 */
+    timeout?: number;
+}
+
+export interface DbExecBatchOptions extends DbTarget {
+    /** 超时时间（秒），默认 30 */
+    timeout?: number;
+}
+
+// 回调函数存储对象
+const callbacks: Map<string, (data: string) => void> = new Map();
+
+// 初始化全局回调函数
+if (typeof window !== "undefined" && !window.assistsxDbCallback) {
+    window.assistsxDbCallback = (data: string) => {
+        let callbackId: string | undefined;
+        try {
+            const json = decodeBase64UTF8(data);
+            const response = JSON.parse(json);
+            callbackId = response.callbackId;
+            if (callbackId) {
+                const callback = callbacks.get(callbackId);
+                if (callback) {
+                    callback(json);
+                }
+            }
+        } catch (e) {
+            console.error("Db callback error:", e);
+        } finally {
+            if (callbackId) {
+                callbacks.delete(callbackId);
+            }
+        }
+    };
+}
+
+function buildDbArguments(
+    target: DbTarget,
+    extra?: Record<string, unknown>
+): Record<string, unknown> {
+    const args: Record<string, unknown> = { ...extra };
+    if (target.dbPath) {
+        args.dbPath = target.dbPath;
+    }
+    if (target.dbName) {
+        args.dbName = target.dbName;
+    }
+    return args;
+}
+
+function normalizeBindArgs(
+    bindArgs?: (string | number | boolean | null)[]
+): (string | null)[] | undefined {
+    if (!bindArgs || bindArgs.length === 0) {
+        return undefined;
+    }
+    return bindArgs.map((value) => {
+        if (value === null) {
+            return null;
+        }
+        return String(value);
+    });
+}
+
+function parseExecResult(data: unknown): DbExecResult {
+    const record = (data ?? {}) as Record<string, unknown>;
+    return {
+        rowsAffected: Number(record.rowsAffected ?? 0),
+        lastInsertRowId: Number(record.lastInsertRowId ?? 0),
+    };
+}
+
+function parseQueryResult(data: unknown): DbQueryResult {
+    const record = (data ?? {}) as Record<string, unknown>;
+    const columns = Array.isArray(record.columns)
+        ? record.columns.map((item) => String(item))
+        : [];
+    const rows = Array.isArray(record.rows) ? (record.rows as DbRow[]) : [];
+    return {
+        columns,
+        rows,
+        rowCount: Number(record.rowCount ?? rows.length),
+    };
+}
+
+function parseExecBatchResult(data: unknown): DbExecBatchResult {
+    const record = (data ?? {}) as Record<string, unknown>;
+    const results = Array.isArray(record.results)
+        ? record.results.map((item) => parseExecResult(item))
+        : [];
+    return {
+        count: Number(record.count ?? results.length),
+        results,
+    };
+}
+
+export class Db {
+    /**
+     * 执行异步调用
+     */
+    private async asyncCall(
+        method: string,
+        args?: Record<string, unknown>,
+        timeout: number = 30
+    ): Promise<CallResponse> {
+        const uuid = generateUUID();
+        const params = {
+            method,
+            arguments: args ? args : undefined,
+            callbackId: uuid,
+        };
+        const promise = new Promise<string>((resolve) => {
+            callbacks.set(uuid, (data: string) => {
+                resolve(data);
+            });
+            setTimeout(() => {
+                callbacks.delete(uuid);
+                resolve(JSON.stringify(new CallResponse(0, null, uuid)));
+            }, timeout * 1000);
+        });
+        window.assistsxDb.call(JSON.stringify(params));
+        const promiseResult = await promise;
+        if (typeof promiseResult !== "string") {
+            throw new Error("Db call failed");
+        }
+        const responseData = JSON.parse(promiseResult);
+        if (responseData.code !== 0) {
+            throw new Error(responseData.message || "Db call failed");
+        }
+        return new CallResponse(
+            responseData.code,
+            responseData.data,
+            responseData.callbackId
+        );
+    }
+
+    /**
+     * 将 query 结果中的 Base64 BLOB 字段解码为 Uint8Array
+     */
+    decodeBlobBase64(base64: string): Uint8Array {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes;
+    }
+
+    /**
+     * 执行非查询 SQL
+     */
+    async exec(sql: string, options: DbCallOptions = {}): Promise<DbExecResult> {
+        const { timeout = 30, bindArgs, ...target } = options;
+        const response = await this.asyncCall(
+            DbCallMethod.exec,
+            buildDbArguments(target, {
+                sql,
+                bindArgs: normalizeBindArgs(bindArgs),
+            }),
+            timeout
+        );
+        return parseExecResult(response.getDataOrNull());
+    }
+
+    /**
+     * 执行查询 SQL
+     */
+    async query(sql: string, options: DbCallOptions = {}): Promise<DbQueryResult> {
+        const { timeout = 30, bindArgs, ...target } = options;
+        const response = await this.asyncCall(
+            DbCallMethod.query,
+            buildDbArguments(target, {
+                sql,
+                bindArgs: normalizeBindArgs(bindArgs),
+            }),
+            timeout
+        );
+        return parseQueryResult(response.getDataOrNull());
+    }
+
+    /**
+     * 事务内批量执行多条 SQL
+     */
+    async execBatch(
+        statements: string[],
+        options: DbExecBatchOptions = {}
+    ): Promise<DbExecBatchResult> {
+        const { timeout = 30, ...target } = options;
+        const response = await this.asyncCall(
+            DbCallMethod.execBatch,
+            buildDbArguments(target, { statements }),
+            timeout
+        );
+        return parseExecBatchResult(response.getDataOrNull());
+    }
+
+    /**
+     * 关闭并释放指定数据库连接
+     */
+    async close(options: DbTarget & { timeout?: number } = {}): Promise<void> {
+        const { timeout = 30, ...target } = options;
+        await this.asyncCall(
+            DbCallMethod.close,
+            buildDbArguments(target),
+            timeout
+        );
+    }
+}
+
+export const db = new Db();

package/src/global.d.ts

@@ -55,6 +55,14 @@ declare global {
             call(method: string): string | null;
         };
         assistsxLogCallback: (data: string) => void;
+        assistsxScreenshot: {
+            call(method: string): string | null;
+        };
+        assistsxScreenshotCallback: (data: string) => void;
+        assistsxDb: {
+            call(method: string): string | null;
+        };
+        assistsxDbCallback: (data: string) => void;
         onAssistsLogUpdate: (encoded: string) => void;
     }
 }

package/src/index.ts

@@ -15,6 +15,7 @@ export * from "./assistsx-async";
 export * from "./step-async";
 export * from "./accessibility-event-filter";
 export * from "./app-info";
+export * from "./plugin-info";
 export * from "./device-info";
 export * from "./step-error";
 export * from "./network/http";
@@ -26,6 +27,10 @@ export * from "./imageutils/image-utils";
 export * from "./gallery/gallery";
 export * from "./mlkit/mlkit";
 export * from "./mlkit/mlkit-call-method";
+export * from "./screenshot/screenshot";
+export * from "./screenshot/screenshot-call-method";
+export * from "./db/db";
+export * from "./db/db-call-method";
 export * from "./barutils/bar-utils";
 export * from "./barutils/bar-utils-call-method";
 export * from "./floatingwindow/float";

package/src/log/log-call-method.ts

@@ -14,6 +14,9 @@ export const LogCallMethod = {
 
     /** 获取日志服务当前域名（origin，无路径；与上传、管理后台同源），对应 AssistsLogDiagnostics.adminWebBaseUrl() */
     getLogServiceBaseUrl: "getLogServiceBaseUrl",
+
+    /** 解析日志文件绝对路径（不创建文件） */
+    resolveLogPath: "resolveLogPath",
 } as const;
 
 /** 与 ASWebView / AssistsLogJavascriptInterface companion 对齐 */