assistsx-js 0.0.2002 → 0.0.2004

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 {
     /**
      * 执行同步调用
@@ -354,15 +376,20 @@ export declare class AssistsX {
     /**
      * 添加无障碍事件监听器
      * @param listener 监听器函数
-     * @returns 监听器ID，用于移除监听器
      */
-    static addAccessibilityEventListener(listener: (event: any) => void): string;
+    static addAccessibilityEventListener(listener: AccessibilityEventListener): void;
+    /**
+     * 判断是否包含无障碍事件监听器
+     * @param listener 监听器函数
+     * @returns 是否包含
+     */
+    static containsAccessibilityEventListener(listener: AccessibilityEventListener): boolean;
     /**
      * 移除无障碍事件监听器
-     * @param listenerId 监听器ID
+     * @param listener 要移除的监听器函数
      * @returns 是否移除成功
      */
-    static removeAccessibilityEventListener(listenerId: string): boolean;
+    static removeAccessibilityEventListener(listener: AccessibilityEventListener): boolean;
     /**
      * 移除所有无障碍事件监听器
      */

package/dist/AssistsX.js

@@ -8,33 +8,45 @@ import { CallResponse } from "./CallResponse";
 import { Bounds } from "./Bounds";
 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) => {
+        let callbackId;
         try {
-            console.log(data);
             const json = decodeBase64UTF8(data);
             const response = JSON.parse(json);
-            const callback = callbacks[response.callbackId];
-            if (callback) {
-                callback(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);
@@ -79,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;
@@ -571,37 +585,28 @@ 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 listener 监听器函数
+     * @returns 是否包含
+     */
+    static containsAccessibilityEventListener(listener) {
+        return accessibilityEventListeners.indexOf(listener) > -1;
     }
     /**
      * 移除无障碍事件监听器
-     * @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.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;

package/dist/Step.d.ts

@@ -2,6 +2,7 @@ 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;
@@ -11,6 +12,10 @@ export declare class Step {
      * 当前执行步骤的ID
      */
     private static _stepId;
+    /**
+     * 步骤拦截器列表
+     */
+    private static _interceptors;
     /**
      * 运行步骤实现
      * @param impl 步骤实现函数
@@ -42,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
      */

package/dist/Step.js

@@ -45,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) {
@@ -113,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
@@ -473,3 +545,7 @@ Step.showLog = false;
  * 当前执行步骤的ID
  */
 Step._stepId = undefined;
+/**
+ * 步骤拦截器列表
+ */
+Step._interceptors = [];

package/package.json

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

package/src/AssistsX.ts

@@ -8,6 +8,33 @@ import { CallResponse } from "./CallResponse";
 import { Bounds } from "./Bounds";
 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,35 +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) => {
+    let callbackId: string | undefined;
     try {
-      console.log(data);
       const json = decodeBase64UTF8(data);
       const response = JSON.parse(json);
-      const callback = callbacks[response.callbackId];
-      if (callback) {
-        callback(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);
       }
@@ -106,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;
@@ -780,41 +820,35 @@ 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 listener 监听器函数
+   * @returns 是否包含
+   */
+  public static containsAccessibilityEventListener(
+    listener: AccessibilityEventListener
+  ): boolean {
+    return accessibilityEventListeners.indexOf(listener) > -1;
   }
 
   /**
    * 移除无障碍事件监听器
-   * @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;

package/src/Step.ts

@@ -16,6 +16,9 @@ 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;
@@ -27,6 +30,11 @@ export class Step {
    */
   private static _stepId: string | undefined = undefined;
 
+  /**
+   * 步骤拦截器列表
+   */
+  private static _interceptors: StepInterceptor[] = [];
+
   /**
    * 运行步骤实现
    * @param impl 步骤实现函数
@@ -77,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
@@ -160,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
    */