assistsx-js 0.0.2001 → 0.0.2003

package/dist/AssistsX.d.ts

@@ -5,6 +5,30 @@
 import { Node } from "./Node";
 import { CallResponse } from "./CallResponse";
 import { Bounds } from "./Bounds";
+/**
+ * 无障碍事件数据结构
+ */
+export interface AccessibilityEventData {
+    packageName: string;
+    className: string;
+    eventType: number;
+    action: number;
+    texts: string[];
+    node: Node;
+}
+/**
+ * 无障碍事件完整结构
+ */
+export interface AccessibilityEvent {
+    callbackId: string;
+    code: number;
+    data: AccessibilityEventData;
+    message: string;
+}
+/**
+ * 无障碍事件监听器类型
+ */
+export type AccessibilityEventListener = (event: AccessibilityEvent) => void;
 /**
  * Web浮动窗口选项接口定义
  */
@@ -17,10 +41,8 @@ export interface WebFloatingWindowOptions {
     maxHeight?: number;
     initialCenter?: boolean;
 }
-export declare const callbacks: {
-    [key: string]: (data: any) => void;
-};
-export declare const accessibilityEventListeners: ((event: any) => void)[];
+export declare const callbacks: Map<string, (data: string) => void>;
+export declare const accessibilityEventListeners: AccessibilityEventListener[];
 export declare class AssistsX {
     /**
      * 执行同步调用
@@ -182,7 +204,7 @@ export declare class AssistsX {
      * @param className 类名
      * @returns 父节点
      */
-    static findFirstParentByTags(className: string): Node;
+    static findFirstParentByTags(node: Node, className: string): Node;
     /**
      * 获取节点的所有子节点
      * @param node 父节点
@@ -354,15 +376,14 @@ export declare class AssistsX {
     /**
      * 添加无障碍事件监听器
      * @param listener 监听器函数
-     * @returns 监听器ID，用于移除监听器
      */
-    static addAccessibilityEventListener(listener: (event: any) => void): string;
+    static addAccessibilityEventListener(listener: AccessibilityEventListener): void;
     /**
      * 移除无障碍事件监听器
-     * @param listenerId 监听器ID
+     * @param listener 要移除的监听器函数
      * @returns 是否移除成功
      */
-    static removeAccessibilityEventListener(listenerId: string): boolean;
+    static removeAccessibilityEventListener(listener: AccessibilityEventListener): boolean;
     /**
      * 移除所有无障碍事件监听器
      */

package/dist/AssistsX.js

@@ -6,28 +6,47 @@ import { Node } from "./Node";
 import { CallMethod } from "./CallMethod";
 import { CallResponse } from "./CallResponse";
 import { Bounds } from "./Bounds";
-import { generateUUID } from "./Utils";
+import { decodeBase64UTF8, generateUUID } from "./Utils";
 // 回调函数存储对象
-export const callbacks = {};
+export const callbacks = new Map();
 // 无障碍事件监听器存储
 export const accessibilityEventListeners = [];
 // 初始化全局回调函数
 if (typeof window !== "undefined" && !window.assistsxCallback) {
     window.assistsxCallback = (data) => {
-        const response = JSON.parse(data);
-        const callback = callbacks[response.callbackId];
-        if (callback) {
-            callback(data);
+        let callbackId;
+        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.log(e);
+        }
+        finally {
+            // 无论成功还是失败，都删除回调函数
+            if (callbackId) {
+                callbacks.delete(callbackId);
+            }
         }
     };
 }
 // 初始化全局无障碍事件函数
 if (typeof window !== "undefined" && !window.onAccessibilityEvent) {
     window.onAccessibilityEvent = (event) => {
-        // 通知所有注册的监听器
+        // 通知所有注册的监听器，每个监听器都有独立的错误处理
         accessibilityEventListeners.forEach((listener) => {
             try {
-                listener(event);
+                //base64 decode
+                const decodedEvent = decodeBase64UTF8(event);
+                const parsedEvent = JSON.parse(decodedEvent);
+                listener(parsedEvent);
             }
             catch (error) {
                 console.error("Accessibility event listener error:", error);
@@ -72,12 +91,14 @@ export class AssistsX {
             callbackId: uuid,
         };
         const promise = new Promise((resolve) => {
-            callbacks[uuid] = (data) => {
+            callbacks.set(uuid, (data) => {
                 resolve(data);
-            };
+            });
             setTimeout(() => {
+                // 超时后删除回调函数
+                callbacks.delete(uuid);
                 resolve(new CallResponse(0, null, uuid));
-            }, 10000);
+            }, 1000 * 30);
         });
         const result = window.assistsx.call(JSON.stringify(params));
         const promiseResult = await promise;
@@ -301,9 +322,10 @@ export class AssistsX {
      * @param className 类名
      * @returns 父节点
      */
-    static findFirstParentByTags(className) {
+    static findFirstParentByTags(node, className) {
         const response = this.call(CallMethod.findFirstParentByTags, {
             args: { className },
+            node,
         });
         return Node.create(response.getDataOrDefault("{}"));
     }
@@ -563,37 +585,20 @@ export class AssistsX {
     /**
      * 添加无障碍事件监听器
      * @param listener 监听器函数
-     * @returns 监听器ID，用于移除监听器
      */
     static addAccessibilityEventListener(listener) {
-        const listenerId = generateUUID();
-        const wrappedListener = (event) => {
-            try {
-                listener(event);
-            }
-            catch (error) {
-                console.error("Accessibility event listener error:", error);
-            }
-        };
-        // 将监听器包装并存储，使用ID作为键
-        accessibilityEventListeners[listenerId] = wrappedListener;
-        accessibilityEventListeners.push(wrappedListener);
-        return listenerId;
+        accessibilityEventListeners.push(listener);
     }
     /**
      * 移除无障碍事件监听器
-     * @param listenerId 监听器ID
+     * @param listener 要移除的监听器函数
      * @returns 是否移除成功
      */
-    static removeAccessibilityEventListener(listenerId) {
-        const listener = accessibilityEventListeners[listenerId];
-        if (listener) {
-            const index = accessibilityEventListeners.indexOf(listener);
-            if (index > -1) {
-                accessibilityEventListeners.splice(index, 1);
-                delete accessibilityEventListeners[listenerId];
-                return true;
-            }
+    static removeAccessibilityEventListener(listener) {
+        const index = accessibilityEventListeners.indexOf(listener);
+        if (index > -1) {
+            accessibilityEventListeners.splice(index, 1);
+            return true;
         }
         return false;
     }

package/dist/AssistsXAsync.d.ts

@@ -152,7 +152,7 @@ export declare class AssistsXAsync {
      * @param className 类名
      * @returns 父节点
      */
-    static findFirstParentByTags(className: string): Promise<Node>;
+    static findFirstParentByTags(node: Node, className: string): Promise<Node>;
     /**
      * 获取节点的所有子节点
      * @param node 父节点

package/dist/AssistsXAsync.js

@@ -25,12 +25,14 @@ export class AssistsXAsync {
             callbackId: uuid,
         };
         const promise = new Promise((resolve) => {
-            callbacks[uuid] = (data) => {
+            callbacks.set(uuid, (data) => {
                 resolve(data);
-            };
+            });
             setTimeout(() => {
+                // 超时后删除回调函数
+                callbacks.delete(uuid);
                 resolve(new CallResponse(0, null, uuid));
-            }, 10000);
+            }, 1000 * 30);
         });
         const result = window.assistsxAsync.call(JSON.stringify(params));
         const promiseResult = await promise;
@@ -258,9 +260,10 @@ export class AssistsXAsync {
      * @param className 类名
      * @returns 父节点
      */
-    static async findFirstParentByTags(className) {
+    static async findFirstParentByTags(node, className) {
         const response = await this.asyncCall(CallMethod.findFirstParentByTags, {
             args: { className },
+            node,
         });
         return Node.create(response.getDataOrDefault("{}"));
     }

package/dist/Node.d.ts

@@ -57,6 +57,12 @@ export declare class Node {
         stepId: string | undefined;
     });
     get async(): NodeAsync;
+    /**
+     * 查找第一个匹配标签的父节点
+     * @param className 类名
+     * @returns 父节点
+     */
+    findFirstParentByTags(className: string): Node;
     /**
      * 对节点执行点击手势
      * @param offsetX X轴偏移

package/dist/Node.js

@@ -21,6 +21,17 @@ export class Node {
     get async() {
         return new NodeAsync(this);
     }
+    /**
+     * 查找第一个匹配标签的父节点
+     * @param className 类名
+     * @returns 父节点
+     */
+    findFirstParentByTags(className) {
+        Step.assert(this.stepId);
+        const node = AssistsX.findFirstParentByTags(this, className);
+        Step.assert(this.stepId);
+        return node;
+    }
     /**
      * 对节点执行点击手势
      * @param offsetX X轴偏移

package/dist/NodeAsync.d.ts

@@ -11,6 +11,12 @@ export declare class NodeAsync {
      * @param node Node实例
      */
     constructor(node: Node);
+    /**
+     * 查找第一个匹配标签的父节点
+     * @param className 类名
+     * @returns 父节点
+     */
+    findFirstParentByTags(className: string): Promise<Node>;
     /**
      * 对节点执行点击手势
      * @param offsetX X轴偏移

package/dist/NodeAsync.js

@@ -9,6 +9,17 @@ export class NodeAsync {
     constructor(node) {
         this.node = node;
     }
+    /**
+     * 查找第一个匹配标签的父节点
+     * @param className 类名
+     * @returns 父节点
+     */
+    async findFirstParentByTags(className) {
+        Step.assert(this.node.stepId);
+        const node = await AssistsXAsync.findFirstParentByTags(this.node, className);
+        Step.assert(this.node.stepId);
+        return node;
+    }
     /**
      * 对节点执行点击手势
      * @param offsetX X轴偏移

package/dist/Step.d.ts

@@ -1,5 +1,8 @@
 import { Node } from "./Node";
 import { StepAsync } from "./StepAsync";
+export type StepResult = Step | undefined;
+export type StepImpl = (step: Step) => Promise<StepResult>;
+export type StepInterceptor = (step: Step) => StepResult | Promise<StepResult>;
 export declare class Step {
     static delayMsDefault: number;
     static readonly repeatCountInfinite: number;
@@ -9,6 +12,10 @@ export declare class Step {
      * 当前执行步骤的ID
      */
     private static _stepId;
+    /**
+     * 步骤拦截器列表
+     */
+    private static _interceptors;
     /**
      * 运行步骤实现
      * @param impl 步骤实现函数
@@ -16,12 +23,9 @@ export declare class Step {
      * @param data 步骤数据
      * @param delayMs 步骤延迟时间(毫秒)
      */
-    static run(impl: (step: Step) => Promise<Step | undefined>, { tag, data, backupSteps, delayMs, }?: {
+    static run(impl: StepImpl, { tag, data, delayMs, }?: {
         tag?: string | undefined;
         data?: any | undefined;
-        backupSteps?: {
-            [key: string]: (step: Step) => Promise<Step | undefined>;
-        } | undefined;
         delayMs?: number;
     }): Promise<Step>;
     /**
@@ -43,6 +47,25 @@ export declare class Step {
      * 停止当前步骤执行
      */
     static stop(): void;
+    /**
+     * 添加步骤拦截器
+     * @param interceptor 拦截器函数
+     */
+    static addInterceptor(interceptor: StepInterceptor): void;
+    /**
+     * 移除步骤拦截器
+     * @param interceptor 要移除的拦截器函数
+     */
+    static removeInterceptor(interceptor: StepInterceptor): void;
+    /**
+     * 清空所有拦截器
+     */
+    static clearInterceptors(): void;
+    /**
+     * 获取所有拦截器
+     * @returns 拦截器数组
+     */
+    static getInterceptors(): StepInterceptor[];
     /**
      * 步骤ID
      */
@@ -70,13 +93,7 @@ export declare class Step {
     /**
      * 步骤实现函数
      */
-    impl: (step: Step) => Promise<Step | undefined>;
-    /**
-     * 备份步骤，可用于在指定的步骤中转向其他步骤
-     */
-    backupSteps: {
-        [key: string]: (step: Step) => Promise<Step | undefined>;
-    } | undefined;
+    impl: StepImpl;
     /**
      * 构造函数
      * @param stepId 步骤ID
@@ -85,14 +102,11 @@ export declare class Step {
      * @param data 步骤数据
      * @param delayMs 步骤延迟时间(毫秒)
      */
-    constructor({ stepId, impl, tag, data, backupSteps, delayMs, repeatCountMax, }: {
+    constructor({ stepId, impl, tag, data, delayMs, repeatCountMax, }: {
         stepId: string;
-        impl: (step: Step) => Promise<Step | undefined>;
+        impl: StepImpl;
         tag?: string | undefined;
         data?: any | undefined;
-        backupSteps?: {
-            [key: string]: (step: Step) => Promise<Step | undefined>;
-        } | undefined;
         delayMs?: number;
         repeatCountMax?: number;
     });
@@ -105,12 +119,9 @@ export declare class Step {
      * @param delayMs 步骤延迟时间(毫秒)
      * @returns 新的步骤实例
      */
-    next(impl: (step: Step) => Promise<Step | undefined>, { tag, data, backupSteps, delayMs, repeatCountMax, }?: {
+    next(impl: StepImpl, { tag, data, delayMs, repeatCountMax, }?: {
         tag?: string | undefined;
         data?: any | undefined;
-        backupSteps?: {
-            [key: string]: (step: Step) => Promise<Step | undefined>;
-        } | undefined;
         delayMs?: number;
         repeatCountMax?: number;
     }): Step;
@@ -122,13 +133,10 @@ export declare class Step {
      * @param delayMs 步骤延迟时间(毫秒)
      * @returns 当前步骤实例
      */
-    repeat({ stepId, tag, data, backupSteps, delayMs, repeatCountMax, }?: {
+    repeat({ stepId, tag, data, delayMs, repeatCountMax, }?: {
         stepId?: string;
         tag?: string | undefined;
         data?: any | undefined;
-        backupSteps?: {
-            [key: string]: (step: Step) => Promise<Step | undefined>;
-        } | undefined;
         delayMs?: number;
         repeatCountMax?: number;
     }): Step;
@@ -239,12 +247,6 @@ export declare class Step {
      * @returns 文本数组
      */
     getAllText(): string[];
-    /**
-     * 查找第一个匹配标签的父节点
-     * @param className 类名
-     * @returns 父节点
-     */
-    findFirstParentByTags(className: string): Node;
     /**
      * 执行点击手势
      * @param x 横坐标

package/dist/Step.js

@@ -15,7 +15,7 @@ export class Step {
      * @param data 步骤数据
      * @param delayMs 步骤延迟时间(毫秒)
      */
-    static async run(impl, { tag, data, backupSteps, delayMs = Step.delayMsDefault, } = {}) {
+    static async run(impl, { tag, data, delayMs = Step.delayMsDefault, } = {}) {
         var _a;
         const stepStore = useStepStore();
         let implnName = impl.name;
@@ -30,7 +30,6 @@ export class Step {
                 impl,
                 tag,
                 data,
-                backupSteps,
                 delayMs,
             });
             while (true) {
@@ -46,7 +45,49 @@ export class Step {
                 if (Step.showLog) {
                     console.log(`执行步骤${implnName}，重复次数${currentStep.repeatCount}`);
                 }
-                nextStep = await currentStep.impl(currentStep);
+                // 执行拦截器
+                let interceptedStep = undefined;
+                for (const interceptor of this._interceptors) {
+                    try {
+                        const result = await interceptor(currentStep);
+                        if (result !== undefined) {
+                            interceptedStep = result;
+                            if (Step.showLog) {
+                                console.log(`步骤${implnName}被拦截器拦截，执行拦截后的步骤`);
+                            }
+                            break;
+                        }
+                    }
+                    catch (e) {
+                        if (Step.showLog) {
+                            console.error(`拦截器执行出错`, e);
+                        }
+                        // 拦截器出错不影响主流程，继续执行原步骤
+                    }
+                }
+                // 如果被拦截，执行拦截后的步骤，否则执行原步骤
+                if (interceptedStep !== undefined) {
+                    // 执行拦截后的步骤，需要处理延迟和重复次数
+                    const stepToExecute = interceptedStep;
+                    // 如果拦截后的步骤有延迟时间，先执行延迟
+                    if (stepToExecute.delayMs) {
+                        if (Step.showLog) {
+                            console.log(`拦截步骤延迟${stepToExecute.delayMs}毫秒`);
+                        }
+                        await stepToExecute.delay(stepToExecute.delayMs);
+                        Step.assert(stepToExecute.stepId);
+                    }
+                    // 打印拦截步骤的执行信息
+                    const interceptedImplName = stepToExecute.impl.name;
+                    if (Step.showLog) {
+                        console.log(`执行拦截步骤${interceptedImplName}，重复次数${stepToExecute.repeatCount}`);
+                    }
+                    // 执行拦截后的步骤
+                    nextStep = await stepToExecute.impl(stepToExecute);
+                }
+                else {
+                    nextStep = await currentStep.impl(currentStep);
+                }
                 if (currentStep.repeatCountMax > Step.repeatCountInfinite &&
                     currentStep.repeatCount > currentStep.repeatCountMax) {
                     if (Step.showLog) {
@@ -114,6 +155,36 @@ export class Step {
     static stop() {
         this._stepId = undefined;
     }
+    /**
+     * 添加步骤拦截器
+     * @param interceptor 拦截器函数
+     */
+    static addInterceptor(interceptor) {
+        this._interceptors.push(interceptor);
+    }
+    /**
+     * 移除步骤拦截器
+     * @param interceptor 要移除的拦截器函数
+     */
+    static removeInterceptor(interceptor) {
+        const index = this._interceptors.indexOf(interceptor);
+        if (index > -1) {
+            this._interceptors.splice(index, 1);
+        }
+    }
+    /**
+     * 清空所有拦截器
+     */
+    static clearInterceptors() {
+        this._interceptors = [];
+    }
+    /**
+     * 获取所有拦截器
+     * @returns 拦截器数组
+     */
+    static getInterceptors() {
+        return [...this._interceptors];
+    }
     /**
      * 构造函数
      * @param stepId 步骤ID
@@ -122,7 +193,7 @@ export class Step {
      * @param data 步骤数据
      * @param delayMs 步骤延迟时间(毫秒)
      */
-    constructor({ stepId, impl, tag, data, backupSteps, delayMs = Step.delayMsDefault, repeatCountMax = Step.repeatCountMaxDefault, }) {
+    constructor({ stepId, impl, tag, data, delayMs = Step.delayMsDefault, repeatCountMax = Step.repeatCountMaxDefault, }) {
         /**
          * 步骤ID
          */
@@ -143,7 +214,6 @@ export class Step {
         this.stepId = stepId;
         this.data = data;
         this.impl = impl;
-        this.backupSteps = backupSteps;
         this.delayMs = delayMs;
         this.repeatCountMax = repeatCountMax;
     }
@@ -158,14 +228,13 @@ export class Step {
      * @param delayMs 步骤延迟时间(毫秒)
      * @returns 新的步骤实例
      */
-    next(impl, { tag, data, backupSteps, delayMs = Step.delayMsDefault, repeatCountMax = Step.repeatCountMaxDefault, } = {}) {
+    next(impl, { tag, data, delayMs = Step.delayMsDefault, repeatCountMax = Step.repeatCountMaxDefault, } = {}) {
         Step.assert(this.stepId);
         return new Step({
             stepId: this.stepId,
             impl,
             tag,
             data: data !== null && data !== void 0 ? data : this.data,
-            backupSteps: backupSteps !== null && backupSteps !== void 0 ? backupSteps : this.backupSteps,
             delayMs,
             repeatCountMax,
         });
@@ -178,13 +247,12 @@ export class Step {
      * @param delayMs 步骤延迟时间(毫秒)
      * @returns 当前步骤实例
      */
-    repeat({ stepId = this.stepId, tag = this.tag, data = this.data, backupSteps = this.backupSteps, delayMs = this.delayMs, repeatCountMax = this.repeatCountMax, } = {}) {
+    repeat({ stepId = this.stepId, tag = this.tag, data = this.data, delayMs = this.delayMs, repeatCountMax = this.repeatCountMax, } = {}) {
         Step.assert(this.stepId);
         this.repeatCount++;
         this.stepId = stepId;
         this.tag = tag;
         this.data = data;
-        this.backupSteps = backupSteps;
         this.delayMs = delayMs;
         this.repeatCountMax = repeatCountMax;
         return this;
@@ -370,17 +438,6 @@ export class Step {
         Step.assert(this.stepId);
         return texts;
     }
-    /**
-     * 查找第一个匹配标签的父节点
-     * @param className 类名
-     * @returns 父节点
-     */
-    findFirstParentByTags(className) {
-        Step.assert(this.stepId);
-        const node = AssistsX.findFirstParentByTags(className);
-        Step.assert(this.stepId);
-        return node;
-    }
     /**
      * 执行点击手势
      * @param x 横坐标
@@ -488,3 +545,7 @@ Step.showLog = false;
  * 当前执行步骤的ID
  */
 Step._stepId = undefined;
+/**
+ * 步骤拦截器列表
+ */
+Step._interceptors = [];

package/dist/StepAsync.d.ts

@@ -102,12 +102,6 @@ export declare class StepAsync {
      * @returns 文本数组
      */
     getAllText(): Promise<string[]>;
-    /**
-     * 查找第一个匹配标签的父节点
-     * @param className 类名
-     * @returns 父节点
-     */
-    findFirstParentByTags(className: string): Promise<Node>;
     /**
      * 执行点击手势
      * @param x 横坐标

package/dist/StepAsync.js

@@ -163,17 +163,6 @@ export class StepAsync {
         Step.assert(this.step.stepId);
         return texts;
     }
-    /**
-     * 查找第一个匹配标签的父节点
-     * @param className 类名
-     * @returns 父节点
-     */
-    async findFirstParentByTags(className) {
-        Step.assert(this.step.stepId);
-        const node = await AssistsXAsync.findFirstParentByTags(className);
-        Step.assert(this.step.stepId);
-        return node;
-    }
     /**
      * 执行点击手势
      * @param x 横坐标

package/dist/Utils.d.ts

@@ -1,2 +1,3 @@
 export declare function sleep(ms: number): Promise<void>;
 export declare function generateUUID(): string;
+export declare function decodeBase64UTF8(base64: string): string;

package/dist/Utils.js

@@ -1,12 +1,20 @@
 // 导出工具函数
 export function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
 }
 // 生成UUID
 export function generateUUID() {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        const r = Math.random() * 16 | 0;
-        const v = c === 'x' ? r : (r & 0x3 | 0x8);
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0;
+        const v = c === "x" ? r : (r & 0x3) | 0x8;
         return v.toString(16);
     });
 }
+export function decodeBase64UTF8(base64) {
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return new TextDecoder("utf-8").decode(bytes);
+}

package/package.json

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

package/src/AssistsX.ts

@@ -6,7 +6,34 @@ import { Node } from "./Node";
 import { CallMethod } from "./CallMethod";
 import { CallResponse } from "./CallResponse";
 import { Bounds } from "./Bounds";
-import { generateUUID } from "./Utils";
+import { decodeBase64UTF8, generateUUID } from "./Utils";
+
+/**
+ * 无障碍事件数据结构
+ */
+export interface AccessibilityEventData {
+  packageName: string;
+  className: string;
+  eventType: number;
+  action: number;
+  texts: string[];
+  node: Node;
+}
+
+/**
+ * 无障碍事件完整结构
+ */
+export interface AccessibilityEvent {
+  callbackId: string;
+  code: number;
+  data: AccessibilityEventData;
+  message: string;
+}
+
+/**
+ * 无障碍事件监听器类型
+ */
+export type AccessibilityEventListener = (event: AccessibilityEvent) => void;
 
 /**
  * Web浮动窗口选项接口定义
@@ -22,29 +49,46 @@ export interface WebFloatingWindowOptions {
 }
 
 // 回调函数存储对象
-export const callbacks: { [key: string]: (data: any) => void } = {};
+export const callbacks: Map<string, (data: string) => void> = new Map();
 
 // 无障碍事件监听器存储
-export const accessibilityEventListeners: ((event: any) => void)[] = [];
+export const accessibilityEventListeners: AccessibilityEventListener[] = [];
 
 // 初始化全局回调函数
 if (typeof window !== "undefined" && !window.assistsxCallback) {
   window.assistsxCallback = (data: string) => {
-    const response = JSON.parse(data);
-    const callback = callbacks[response.callbackId];
-    if (callback) {
-      callback(data);
+    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.log(e);
+    } finally {
+      // 无论成功还是失败，都删除回调函数
+      if (callbackId) {
+        callbacks.delete(callbackId);
+      }
     }
   };
 }
 
 // 初始化全局无障碍事件函数
 if (typeof window !== "undefined" && !window.onAccessibilityEvent) {
-  window.onAccessibilityEvent = (event: any) => {
-    // 通知所有注册的监听器
+  window.onAccessibilityEvent = (event: string) => {
+    // 通知所有注册的监听器，每个监听器都有独立的错误处理
     accessibilityEventListeners.forEach((listener) => {
       try {
-        listener(event);
+        //base64 decode
+        const decodedEvent = decodeBase64UTF8(event);
+        const parsedEvent: AccessibilityEvent = JSON.parse(decodedEvent);
+        listener(parsedEvent);
       } catch (error) {
         console.error("Accessibility event listener error:", error);
       }
@@ -100,12 +144,14 @@ export class AssistsX {
       callbackId: uuid,
     };
     const promise = new Promise((resolve) => {
-      callbacks[uuid] = (data: any) => {
+      callbacks.set(uuid, (data: string) => {
         resolve(data);
-      };
+      });
       setTimeout(() => {
+        // 超时后删除回调函数
+        callbacks.delete(uuid);
         resolve(new CallResponse(0, null, uuid));
-      }, 10000);
+      }, 1000 * 30);
     });
     const result = window.assistsx.call(JSON.stringify(params));
     const promiseResult = await promise;
@@ -411,9 +457,10 @@ export class AssistsX {
    * @param className 类名
    * @returns 父节点
    */
-  public static findFirstParentByTags(className: string): Node {
+  public static findFirstParentByTags(node: Node, className: string): Node {
     const response = this.call(CallMethod.findFirstParentByTags, {
       args: { className },
+      node,
     });
     return Node.create(response.getDataOrDefault("{}"));
   }
@@ -773,41 +820,25 @@ export class AssistsX {
   /**
    * 添加无障碍事件监听器
    * @param listener 监听器函数
-   * @returns 监听器ID，用于移除监听器
    */
   public static addAccessibilityEventListener(
-    listener: (event: any) => void
-  ): string {
-    const listenerId = generateUUID();
-    const wrappedListener = (event: any) => {
-      try {
-        listener(event);
-      } catch (error) {
-        console.error("Accessibility event listener error:", error);
-      }
-    };
-
-    // 将监听器包装并存储，使用ID作为键
-    (accessibilityEventListeners as any)[listenerId] = wrappedListener;
-    accessibilityEventListeners.push(wrappedListener);
-
-    return listenerId;
+    listener: AccessibilityEventListener
+  ): void {
+    accessibilityEventListeners.push(listener);
   }
 
   /**
    * 移除无障碍事件监听器
-   * @param listenerId 监听器ID
+   * @param listener 要移除的监听器函数
    * @returns 是否移除成功
    */
-  public static removeAccessibilityEventListener(listenerId: string): boolean {
-    const listener = (accessibilityEventListeners as any)[listenerId];
-    if (listener) {
-      const index = accessibilityEventListeners.indexOf(listener);
-      if (index > -1) {
-        accessibilityEventListeners.splice(index, 1);
-        delete (accessibilityEventListeners as any)[listenerId];
-        return true;
-      }
+  public static removeAccessibilityEventListener(
+    listener: AccessibilityEventListener
+  ): boolean {
+    const index = accessibilityEventListeners.indexOf(listener);
+    if (index > -1) {
+      accessibilityEventListeners.splice(index, 1);
+      return true;
     }
     return false;
   }

package/src/AssistsXAsync.ts

@@ -29,12 +29,14 @@ export class AssistsXAsync {
       callbackId: uuid,
     };
     const promise = new Promise((resolve) => {
-      callbacks[uuid] = (data: any) => {
+      callbacks.set(uuid, (data: string) => {
         resolve(data);
-      };
+      });
       setTimeout(() => {
+        // 超时后删除回调函数
+        callbacks.delete(uuid);
         resolve(new CallResponse(0, null, uuid));
-      }, 10000);
+      }, 1000 * 30);
     });
     const result = window.assistsxAsync.call(JSON.stringify(params));
     const promiseResult = await promise;
@@ -347,9 +349,13 @@ export class AssistsXAsync {
    * @param className 类名
    * @returns 父节点
    */
-  public static async findFirstParentByTags(className: string): Promise<Node> {
+  public static async findFirstParentByTags(
+    node: Node,
+    className: string
+  ): Promise<Node> {
     const response = await this.asyncCall(CallMethod.findFirstParentByTags, {
       args: { className },
+      node,
     });
     return Node.create(response.getDataOrDefault("{}"));
   }

package/src/Node.ts

@@ -84,6 +84,18 @@ export class Node {
     return new NodeAsync(this);
   }
 
+  /**
+   * 查找第一个匹配标签的父节点
+   * @param className 类名
+   * @returns 父节点
+   */
+  public findFirstParentByTags(className: string): Node {
+    Step.assert(this.stepId);
+    const node = AssistsX.findFirstParentByTags(this, className);
+    Step.assert(this.stepId);
+    return node;
+  }
+
   /**
    * 对节点执行点击手势
    * @param offsetX X轴偏移

package/src/NodeAsync.ts

@@ -18,7 +18,20 @@ export class NodeAsync {
   constructor(node: Node) {
     this.node = node;
   }
-
+  /**
+   * 查找第一个匹配标签的父节点
+   * @param className 类名
+   * @returns 父节点
+   */
+  public async findFirstParentByTags(className: string): Promise<Node> {
+    Step.assert(this.node.stepId);
+    const node = await AssistsXAsync.findFirstParentByTags(
+      this.node,
+      className
+    );
+    Step.assert(this.node.stepId);
+    return node;
+  }
   /**
    * 对节点执行点击手势
    * @param offsetX X轴偏移

package/src/Step.ts

@@ -10,6 +10,15 @@ import { generateUUID } from "./Utils";
 import { StepError } from "./StepError";
 import { StepAsync } from "./StepAsync";
 
+// 步骤结果类型，可以是Step实例或undefined
+export type StepResult = Step | undefined;
+
+// 步骤实现函数类型
+export type StepImpl = (step: Step) => Promise<StepResult>;
+
+// 步骤拦截器函数类型
+export type StepInterceptor = (step: Step) => StepResult | Promise<StepResult>;
+
 export class Step {
   static delayMsDefault: number = 1000;
   static readonly repeatCountInfinite: number = -1;
@@ -21,6 +30,11 @@ export class Step {
    */
   private static _stepId: string | undefined = undefined;
 
+  /**
+   * 步骤拦截器列表
+   */
+  private static _interceptors: StepInterceptor[] = [];
+
   /**
    * 运行步骤实现
    * @param impl 步骤实现函数
@@ -29,18 +43,14 @@ export class Step {
    * @param delayMs 步骤延迟时间(毫秒)
    */
   static async run(
-    impl: (step: Step) => Promise<Step | undefined>,
+    impl: StepImpl,
     {
       tag,
       data,
-      backupSteps,
       delayMs = Step.delayMsDefault,
     }: {
       tag?: string | undefined;
       data?: any | undefined;
-      backupSteps?:
-        | { [key: string]: (step: Step) => Promise<Step | undefined> }
-        | undefined;
       delayMs?: number;
     } = {}
   ): Promise<Step> {
@@ -58,7 +68,6 @@ export class Step {
         impl,
         tag,
         data,
-        backupSteps,
         delayMs,
       });
       while (true) {
@@ -76,7 +85,54 @@ export class Step {
             `执行步骤${implnName}，重复次数${currentStep.repeatCount}`
           );
         }
-        nextStep = await currentStep.impl(currentStep);
+
+        // 执行拦截器
+        let interceptedStep: StepResult = undefined;
+        for (const interceptor of this._interceptors) {
+          try {
+            const result = await interceptor(currentStep);
+            if (result !== undefined) {
+              interceptedStep = result;
+              if (Step.showLog) {
+                console.log(`步骤${implnName}被拦截器拦截，执行拦截后的步骤`);
+              }
+              break;
+            }
+          } catch (e: any) {
+            if (Step.showLog) {
+              console.error(`拦截器执行出错`, e);
+            }
+            // 拦截器出错不影响主流程，继续执行原步骤
+          }
+        }
+
+        // 如果被拦截，执行拦截后的步骤，否则执行原步骤
+        if (interceptedStep !== undefined) {
+          // 执行拦截后的步骤，需要处理延迟和重复次数
+          const stepToExecute = interceptedStep;
+
+          // 如果拦截后的步骤有延迟时间，先执行延迟
+          if (stepToExecute.delayMs) {
+            if (Step.showLog) {
+              console.log(`拦截步骤延迟${stepToExecute.delayMs}毫秒`);
+            }
+            await stepToExecute.delay(stepToExecute.delayMs);
+            Step.assert(stepToExecute.stepId);
+          }
+
+          // 打印拦截步骤的执行信息
+          const interceptedImplName = stepToExecute.impl.name;
+          if (Step.showLog) {
+            console.log(
+              `执行拦截步骤${interceptedImplName}，重复次数${stepToExecute.repeatCount}`
+            );
+          }
+
+          // 执行拦截后的步骤
+          nextStep = await stepToExecute.impl(stepToExecute);
+        } else {
+          nextStep = await currentStep.impl(currentStep);
+        }
         if (
           currentStep.repeatCountMax > Step.repeatCountInfinite &&
           currentStep.repeatCount > currentStep.repeatCountMax
@@ -159,6 +215,40 @@ export class Step {
     this._stepId = undefined;
   }
 
+  /**
+   * 添加步骤拦截器
+   * @param interceptor 拦截器函数
+   */
+  static addInterceptor(interceptor: StepInterceptor): void {
+    this._interceptors.push(interceptor);
+  }
+
+  /**
+   * 移除步骤拦截器
+   * @param interceptor 要移除的拦截器函数
+   */
+  static removeInterceptor(interceptor: StepInterceptor): void {
+    const index = this._interceptors.indexOf(interceptor);
+    if (index > -1) {
+      this._interceptors.splice(index, 1);
+    }
+  }
+
+  /**
+   * 清空所有拦截器
+   */
+  static clearInterceptors(): void {
+    this._interceptors = [];
+  }
+
+  /**
+   * 获取所有拦截器
+   * @returns 拦截器数组
+   */
+  static getInterceptors(): StepInterceptor[] {
+    return [...this._interceptors];
+  }
+
   /**
    * 步骤ID
    */
@@ -192,14 +282,7 @@ export class Step {
   /**
    * 步骤实现函数
    */
-  impl: (step: Step) => Promise<Step | undefined>;
-
-  /**
-   * 备份步骤，可用于在指定的步骤中转向其他步骤
-   */
-  backupSteps:
-    | { [key: string]: (step: Step) => Promise<Step | undefined> }
-    | undefined;
+  impl: StepImpl;
 
   /**
    * 构造函数
@@ -214,17 +297,13 @@ export class Step {
     impl,
     tag,
     data,
-    backupSteps,
     delayMs = Step.delayMsDefault,
     repeatCountMax = Step.repeatCountMaxDefault,
   }: {
     stepId: string;
-    impl: (step: Step) => Promise<Step | undefined>;
+    impl: StepImpl;
     tag?: string | undefined;
     data?: any | undefined;
-    backupSteps?:
-      | { [key: string]: (step: Step) => Promise<Step | undefined> }
-      | undefined;
     delayMs?: number;
     repeatCountMax?: number;
   }) {
@@ -232,7 +311,6 @@ export class Step {
     this.stepId = stepId;
     this.data = data;
     this.impl = impl;
-    this.backupSteps = backupSteps;
     this.delayMs = delayMs;
     this.repeatCountMax = repeatCountMax;
   }
@@ -249,19 +327,15 @@ export class Step {
    * @returns 新的步骤实例
    */
   next(
-    impl: (step: Step) => Promise<Step | undefined>,
+    impl: StepImpl,
     {
       tag,
       data,
-      backupSteps,
       delayMs = Step.delayMsDefault,
       repeatCountMax = Step.repeatCountMaxDefault,
     }: {
       tag?: string | undefined;
       data?: any | undefined;
-      backupSteps?:
-        | { [key: string]: (step: Step) => Promise<Step | undefined> }
-        | undefined;
       delayMs?: number;
       repeatCountMax?: number;
     } = {}
@@ -272,7 +346,6 @@ export class Step {
       impl,
       tag,
       data: data ?? this.data,
-      backupSteps: backupSteps ?? this.backupSteps,
       delayMs,
       repeatCountMax,
     });
@@ -290,16 +363,12 @@ export class Step {
     stepId = this.stepId,
     tag = this.tag,
     data = this.data,
-    backupSteps = this.backupSteps,
     delayMs = this.delayMs,
     repeatCountMax = this.repeatCountMax,
   }: {
     stepId?: string;
     tag?: string | undefined;
     data?: any | undefined;
-    backupSteps?:
-      | { [key: string]: (step: Step) => Promise<Step | undefined> }
-      | undefined;
     delayMs?: number;
     repeatCountMax?: number;
   } = {}): Step {
@@ -308,7 +377,6 @@ export class Step {
     this.stepId = stepId;
     this.tag = tag;
     this.data = data;
-    this.backupSteps = backupSteps;
     this.delayMs = delayMs;
     this.repeatCountMax = repeatCountMax;
     return this;
@@ -550,18 +618,6 @@ export class Step {
     return texts;
   }
 
-  /**
-   * 查找第一个匹配标签的父节点
-   * @param className 类名
-   * @returns 父节点
-   */
-  public findFirstParentByTags(className: string): Node {
-    Step.assert(this.stepId);
-    const node = AssistsX.findFirstParentByTags(className);
-    Step.assert(this.stepId);
-    return node;
-  }
-
   /**
    * 执行点击手势
    * @param x 横坐标

package/src/StepAsync.ts

@@ -231,18 +231,6 @@ export class StepAsync {
     return texts;
   }
 
-  /**
-   * 查找第一个匹配标签的父节点
-   * @param className 类名
-   * @returns 父节点
-   */
-  public async findFirstParentByTags(className: string): Promise<Node> {
-    Step.assert(this.step.stepId);
-    const node = await AssistsXAsync.findFirstParentByTags(className);
-    Step.assert(this.step.stepId);
-    return node;
-  }
-
   /**
    * 执行点击手势
    * @param x 横坐标

package/src/Utils.ts

@@ -1,13 +1,22 @@
 // 导出工具函数
 export function sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // 生成UUID
 export function generateUUID(): string {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-        const r = Math.random() * 16 | 0;
-        const v = c === 'x' ? r : (r & 0x3 | 0x8);
-        return v.toString(16);
-    });
-}
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+    const r = (Math.random() * 16) | 0;
+    const v = c === "x" ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
+export function decodeBase64UTF8(base64: string): string {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return new TextDecoder("utf-8").decode(bytes);
+}