注册 登录
发贴工具
自动发帖软件»群发软件 › 群发软件公告教程 › AIWORK源码分享 › 无障碍方式双指向中间滑动放大缩小完整示例
返回列表 发帖
查看: 11|回复: 0
打印 上一主题 下一主题

[24小时收录超级好的网站] 无障碍方式双指向中间滑动放大缩小完整示例

[复制链接]

2607

主题

2655

帖子

1万

积分

积分
15820
跳转到指定楼层
楼主
发帖软件 发表于 7 小时前 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
无障碍方式双指向中间滑动放大缩小完整示例
无障碍方式双指向中间滑动放大缩小完整示例 群发软件发帖工具
  1. /**
  2. * ============================================================
  3. * AIWROK - 双指向中间滑动（捏合手势）完整示例【无碍模式】
  4. * ============================================================
  5. * 核心功能：
  6. *   1. auto.dispatchGesture([path1, path2])  —— 同时执行多条路径，实现多点触控
  7. *   2. new path() + setDurTime() + addPoint() —— 构建单根手指的滑动轨迹
  8. *
  9. * 手势说明：
  10. *   - 捏合（缩小）：左指向右滑 + 右指向左滑，两指同时向中间靠拢
  11. *   - 放大（张开）：左指向左滑 + 右指向右滑，两指同时向外分开（附带示例）
  12. *
  13. * 无碍模式特性：
  14. *   1. 环境自检：运行前自动检查 path / auto.dispatchGesture 是否可用
  15. *   2. 安全封装：创建路径、执行手势全部走 try-catch，任何一步失败都不崩溃
  16. *   3. 参数校验：百分比参数越界自动纠正到合法范围
  17. *   4. 单个手势失败不影响后续手势继续执行
  18. *   5. 失败降级：返回 false 并给出排查建议，方便上层逻辑做备选方案
  19. *
  20. * 【重要】本文件仅适配"无碍模式"（无障碍服务）运行：
  21. *   - 手势一律使用 auto.dispatchGesture([path1, path2]) + new path()
  22. *   - 运行前请确认已开启 AIWROK 无障碍服务权限
  23. * ============================================================
  24. */

  26. // =====================================================
  27. //  0. 环境自检（脚本运行时会自动执行一次）
  28. // =====================================================
  29. var _GESTURE_OK = true;

  31. (function _gestureSelfCheck() {
  32.     var msg = "【自检】捏合手势运行环境:\n";
  33.     try {
  34.         if (typeof path === 'undefined') {
  35.             msg += "  × path 对象不可用（无法创建手势路径）\n";
  36.             _GESTURE_OK = false;
  37.         } else {
  38.             msg += "  ✓ path 对象可用\n";
  39.         }

  41.         if (typeof auto === 'undefined' || typeof auto.dispatchGesture !== 'function') {
  42.             msg += "  × auto.dispatchGesture 不可用（无法执行手势）\n";
  43.             _GESTURE_OK = false;
  44.         } else {
  45.             msg += "  ✓ auto.dispatchGesture 可用\n";
  46.         }

  48.         // 屏幕尺寸检测（可选，失败可用默认值）
  49.         try {
  50.             if (typeof screen !== 'undefined'
  51.                 && typeof screen.getScreenWidth === 'function'
  52.                 && typeof screen.getScreenHeight === 'function') {
  53.                 msg += "  ✓ screen 尺寸可用: " + screen.getScreenWidth() + " x " + screen.getScreenHeight() + "\n";
  54.             } else if (typeof device !== 'undefined' && typeof device.width === 'number') {
  55.                 msg += "  ✓ device 尺寸可用: " + device.width + " x " + device.height + "\n";
  56.             } else {
  57.                 msg += "  ⚠ 尺寸获取不可用，将回退 1080 x 1920\n";
  58.             }
  59.         } catch (e) {
  60.             msg += "  ⚠ 尺寸读取异常: " + e + "，将回退 1080 x 1920\n";
  61.         }

  63.         if (_GESTURE_OK) {
  64.             msg += "  ✓ 自检通过，可以正常执行捏合手势";
  65.         } else {
  66.             msg += "  ✗ 自检未通过！请检查是否已开启 AIWROK 无障碍服务权限";
  67.         }
  68.     } catch (e) {
  69.         msg += "  ✗ 自检过程异常: " + e + "\n";
  70.         _GESTURE_OK = false;
  71.     }
  72.     _log(msg);
  73. })();

  75. // =====================================================
  76. //  1. 安全工具函数
  77. // =====================================================

  79. /**
  80. * 安全获取屏幕尺寸（任何异常都回退默认值）
  81. */
  82. function _gestureGetScreen() {
  83.     var w = 1080, h = 1920;
  84.     try {
  85.         if (typeof screen !== 'undefined') {
  86.             if (typeof screen.getScreenWidth === 'function')  w = screen.getScreenWidth();
  87.             if (typeof screen.getScreenHeight === 'function') h = screen.getScreenHeight();
  88.         } else if (typeof device !== 'undefined') {
  89.             if (typeof device.width === 'number')  w = device.width;
  90.             if (typeof device.height === 'number') h = device.height;
  91.         }
  92.         // 防脏数据：尺寸为 0 或非数字时回退默认
  93.         w = (typeof w === 'number' && w > 0) ? w : 1080;
  94.         h = (typeof h === 'number' && h > 0) ? h : 1920;
  95.     } catch (e) {
  96.         _log("⚠ 获取屏幕尺寸异常，使用默认值: " + e);
  97.     }
  98.     return { w: w, h: h };
  99. }

  101. /**
  102. * 参数校验：把百分比约束到 0~1 之间（防止越界导致手势报错）
  103. */
  104. function _clampPercent(v, fallback) {
  105.     try {
  106.         v = parseFloat(v);
  107.         if (isNaN(v)) return fallback;
  108.         if (v < 0) return 0;
  109.         if (v > 1) return 1;
  110.         return v;
  111.     } catch (e) {
  112.         return fallback;
  113.     }
  114. }

  116. /**
  117. * 安全创建单指路径
  118. * @param points 坐标点数组，如 [[x1,y1],[x2,y2]]
  119. * @param duration 时长(毫秒)
  120. * @return path 对象；创建失败返回 null
  121. */
  122. function _safeCreatePath(points, duration) {
  123.     try {
  124.         if (typeof path === 'undefined') {
  125.             _log("✗ path 对象不可用，无法创建路径");
  126.             return null;
  127.         }
  128.         if (!points || points.length < 2) {
  129.             _log("✗ 路径点不足（至少需要 2 个点）");
  130.             return null;
  131.         }
  132.         var p = new path();
  133.         p.setDurTime(duration > 0 ? duration : 600);
  134.         for (var i = 0; i < points.length; i++) {
  135.             var pt = points[i];
  136.             if (!pt || typeof pt[0] !== 'number' || typeof pt[1] !== 'number') {
  137.                 _log("✗ 路径点[" + i + "]非法，跳过该点: " + JSON.stringify(pt));
  138.                 continue;
  139.             }
  140.             p.addPoint(pt[0], pt[1]);
  141.         }
  142.         return p;
  143.     } catch (e) {
  144.         _log("✗ 创建路径异常: " + e);
  145.         return null;
  146.     }
  147. }

  149. /**
  150. * 安全执行手势（无碍核心：任何情况都不抛出异常）
  151. * @param paths path 对象数组
  152. * @return true/false
  153. */
  154. function _safeDispatchGesture(paths) {
  155.     try {
  156.         if (!_GESTURE_OK) {
  157.             _log("✗ 环境自检未通过（path/dispatchGesture 不可用），跳过手势");
  158.             return false;
  159.         }
  160.         if (!paths || paths.length === 0) {
  161.             _log("✗ 手势路径数组为空，不执行");
  162.             return false;
  163.         }
  164.         if (typeof auto === 'undefined' || typeof auto.dispatchGesture !== 'function') {
  165.             _log("✗ auto.dispatchGesture 不可用，无法执行手势");
  166.             return false;
  167.         }
  168.         // 过滤掉创建失败(null)的路径，至少要有一条有效路径
  169.         var valid = [];
  170.         for (var i = 0; i < paths.length; i++) {
  171.             if (paths[i]) valid.push(paths[i]);
  172.         }
  173.         if (valid.length === 0) {
  174.             _log("✗ 没有有效的路径对象，不执行手势");
  175.             return false;
  176.         }
  177.         var result = auto.dispatchGesture(valid);
  178.         if (result === true || result === 1) {
  179.             return true;
  180.         }
  181.         _log("✗ dispatchGesture 返回失败（可能是权限不足或当前界面不支持手势）");
  182.         return false;
  183.     } catch (e) {
  184.         _log("✗ 执行手势异常: " + e);
  185.         return false;
  186.     }
  187. }

  189. /**
  190. * 手势失败时的排查提示（无碍模式：失败不静默，给线索）
  191. */
  192. function _gestureFailHint() {
  193.     _log("  └─ 排查建议:");
  194.     _log("      1. 确认已开启 AIWROK 的【无障碍服务】权限");
  195.     _log("      2. 确认当前处于支持双指捏合的界面（如看图/地图，桌面可能没反应）");
  196.     _log("      3. 确认无障碍服务没有与其他应用冲突");
  197. }

  199. /**
  200. * 日志工具：兼容 print.log / console.log
  201. */
  202. function _log(msg) {
  203.     try {
  204.         if (typeof print !== 'undefined' && typeof print.log === 'function') {
  205.             print.log(msg);
  206.         } else if (typeof console !== 'undefined' && typeof console.log === 'function') {
  207.             console.log(msg);
  208.         }
  209.     } catch (e) {
  210.         // 日志失败直接忽略，不影响主体功能
  211.     }
  212. }

  214. // =====================================================
  215. //  2. 无碍模式捏合工具函数（可直接复用）
  216. // =====================================================

  218. /**
  219. * 水平捏合（左指向右 + 右指向左 → 向中间滑动）
  220. * @param leftStartXPercent  左指起点 X 百分比 0~1
  221. * @param rightStartXPercent 右指起点 X 百分比 0~1
  222. * @param yPercent           捏合中心线 Y 百分比 0~1
  223. * @param convergePercent    向中间收敛位置（0.5 = 正中心）
  224. * @param duration           时长(毫秒)
  225. */
  226. function pinchHorizontal(leftStartXPercent, rightStartXPercent, yPercent, convergePercent, duration) {
  227.     try {
  228.         leftStartXPercent  = _clampPercent(leftStartXPercent, 0.25);
  229.         rightStartXPercent = _clampPercent(rightStartXPercent, 0.75);
  230.         yPercent           = _clampPercent(yPercent, 0.5);
  231.         convergePercent    = _clampPercent(convergePercent, 0.5);
  232.         duration           = (typeof duration === 'number' && duration > 0) ? duration : 600;

  234.         var s = _gestureGetScreen();
  235.         var y  = s.h * yPercent;
  236.         var cx = s.w * convergePercent;
  237.         var gap = s.w * 0.05;

  239.         // 左指：起点 → 中心左侧（留间距不撞车）
  240.         var pL = _safeCreatePath([
  241.             [s.w * leftStartXPercent, y],
  242.             [cx - gap, y]
  243.         ], duration);
  244.         // 右指：起点 → 中心右侧
  245.         var pR = _safeCreatePath([
  246.             [s.w * rightStartXPercent, y],
  247.             [cx + gap, y]
  248.         ], duration);

  250.         _log("水平捏合: 左 " + (leftStartXPercent * 100).toFixed(0) + "% → 中心左"
  251.              + "，右 " + (rightStartXPercent * 100).toFixed(0) + "% → 中心右"
  252.              + "，Y=" + (yPercent * 100).toFixed(0) + "%，时长 " + duration + "ms");

  254.         var ok = _safeDispatchGesture([pL, pR]);
  255.         _log(ok ? "✓ 水平捏合执行成功" : "✗ 水平捏合执行失败");
  256.         if (!ok) _gestureFailHint();
  257.         return ok;
  258.     } catch (e) {
  259.         _log("✗ 水平捏合函数异常: " + e);
  260.         return false;
  261.     }
  262. }

  264. /**
  265. * 垂直捏合（上指下滑 + 下指上滑 → 向中间）
  266. * @param topStartYPercent    上指起点 Y 百分比 0~1
  267. * @param bottomStartYPercent 下指起点 Y 百分比 0~1
  268. * @param xPercent            捏合中心线 X 百分比 0~1
  269. * @param convergePercent     向中间收敛位置（0.5 = 正中心）
  270. * @param duration            时长(毫秒)
  271. */
  272. function pinchVertical(topStartYPercent, bottomStartYPercent, xPercent, convergePercent, duration) {
  273.     try {
  274.         topStartYPercent    = _clampPercent(topStartYPercent, 0.25);
  275.         bottomStartYPercent = _clampPercent(bottomStartYPercent, 0.75);
  276.         xPercent            = _clampPercent(xPercent, 0.5);
  277.         convergePercent     = _clampPercent(convergePercent, 0.5);
  278.         duration            = (typeof duration === 'number' && duration > 0) ? duration : 600;

  280.         var s = _gestureGetScreen();
  281.         var x  = s.w * xPercent;
  282.         var cy = s.h * convergePercent;
  283.         var gap = s.h * 0.05;

  285.         // 上指：顶部 → 中心上方
  286.         var pT = _safeCreatePath([
  287.             [x, s.h * topStartYPercent],
  288.             [x, cy - gap]
  289.         ], duration);
  290.         // 下指：底部 → 中心下方
  291.         var pB = _safeCreatePath([
  292.             [x, s.h * bottomStartYPercent],
  293.             [x, cy + gap]
  294.         ], duration);

  296.         _log("垂直捏合: 上 " + (topStartYPercent * 100).toFixed(0) + "% + 下 "
  297.              + (bottomStartYPercent * 100).toFixed(0) + "% → 中心，X="
  298.              + (xPercent * 100).toFixed(0) + "%，时长 " + duration + "ms");

  300.         var ok = _safeDispatchGesture([pT, pB]);
  301.         _log(ok ? "✓ 垂直捏合执行成功" : "✗ 垂直捏合执行失败");
  302.         if (!ok) _gestureFailHint();
  303.         return ok;
  304.     } catch (e) {
  305.         _log("✗ 垂直捏合函数异常: " + e);
  306.         return false;
  307.     }
  308. }

  310. /**
  311. * 对角线捏合（左上 + 右下 → 中心，看图缩小最常用）
  312. * @param duration 时长(毫秒)
  313. */
  314. function pinchDiagonal(duration) {
  315.     try {
  316.         duration = (typeof duration === 'number' && duration > 0) ? duration : 700;
  317.         var s = _gestureGetScreen();
  318.         var cx = s.w * 0.5, cy = s.h * 0.5;
  319.         var gx = s.w * 0.05, gy = s.h * 0.05;

  321.         var p1 = _safeCreatePath([
  322.             [s.w * 0.15, s.h * 0.20],
  323.             [cx - gx, cy - gy]
  324.         ], duration);
  325.         var p2 = _safeCreatePath([
  326.             [s.w * 0.85, s.h * 0.80],
  327.             [cx + gx, cy + gy]
  328.         ], duration);

  330.         _log("对角线捏合: 左上(15%,20%) + 右下(85%,80%) → 中心，时长 " + duration + "ms");

  332.         var ok = _safeDispatchGesture([p1, p2]);
  333.         _log(ok ? "✓ 对角线捏合执行成功" : "✗ 对角线捏合执行失败");
  334.         if (!ok) _gestureFailHint();
  335.         return ok;
  336.     } catch (e) {
  337.         _log("✗ 对角线捏合函数异常: " + e);
  338.         return false;
  339.     }
  340. }

  342. /**
  343. * 通用双指捏合（任意起点 + 指定收敛中心）
  344. * @param start1   起点1 {x:0~1, y:0~1}
  345. * @param start2   起点2 {x:0~1, y:0~1}
  346. * @param center   收敛中心 {x:0~1, y:0~1}
  347. * @param duration 时长(毫秒)
  348. */
  349. function pinchGeneric(start1, start2, center, duration) {
  350.     try {
  351.         if (!start1 || !start2 || typeof start1.x !== 'number' || typeof start2.x !== 'number') {
  352.             _log("✗ pinchGeneric 参数错误：start1/start2 必填且必须含 x/y 百分比");
  353.             return false;
  354.         }
  355.         var s = _gestureGetScreen();
  356.         center   = center   || { x: 0.5, y: 0.5 };
  357.         duration = (typeof duration === 'number' && duration > 0) ? duration : 700;
  358.         var ratio = 0.85; // 向中心靠近比例（留间距避免两指重合被识别成单指）

  360.         var cx = s.w * _clampPercent(center.x, 0.5);
  361.         var cy = s.h * _clampPercent(center.y, 0.5);

  363.         var p1 = _safeCreatePath([
  364.             [s.w * _clampPercent(start1.x, 0.25), s.h * _clampPercent(start1.y, 0.25)],
  365.             [s.w * _clampPercent(start1.x, 0.25) + (cx - s.w * _clampPercent(start1.x, 0.25)) * ratio,
  366.              s.h * _clampPercent(start1.y, 0.25) + (cy - s.h * _clampPercent(start1.y, 0.25)) * ratio]
  367.         ], duration);

  369.         var p2 = _safeCreatePath([
  370.             [s.w * _clampPercent(start2.x, 0.75), s.h * _clampPercent(start2.y, 0.75)],
  371.             [s.w * _clampPercent(start2.x, 0.75) + (cx - s.w * _clampPercent(start2.x, 0.75)) * ratio,
  372.              s.h * _clampPercent(start2.y, 0.75) + (cy - s.h * _clampPercent(start2.y, 0.75)) * ratio]
  373.         ], duration);

  375.         _log("通用捏合: (" + start1.x + "," + start1.y + ") + (" + start2.x + "," + start2.y
  376.              + ") → 中心(" + center.x + "," + center.y + ")，时长 " + duration + "ms");

  378.         var ok = _safeDispatchGesture([p1, p2]);
  379.         _log(ok ? "✓ 通用捏合执行成功" : "✗ 通用捏合执行失败");
  380.         if (!ok) _gestureFailHint();
  381.         return ok;
  382.     } catch (e) {
  383.         _log("✗ 通用捏合函数异常: " + e);
  384.         return false;
  385.     }
  386. }

  388. /**
  389. * 水平放大（与捏合相反，双指向外分开）
  390. * @param duration 时长(毫秒)
  391. */
  392. function zoomHorizontal(duration) {
  393.     try {
  394.         duration = (typeof duration === 'number' && duration > 0) ? duration : 600;
  395.         var s = _gestureGetScreen();
  396.         var y   = s.h * 0.5;
  397.         var gap = s.w * 0.05;

  399.         var pL = _safeCreatePath([
  400.             [s.w * 0.5 - gap, y],
  401.             [s.w * 0.20, y]
  402.         ], duration);
  403.         var pR = _safeCreatePath([
  404.             [s.w * 0.5 + gap, y],
  405.             [s.w * 0.80, y]
  406.         ], duration);

  408.         _log("水平放大: 中间 → 左右张开，时长 " + duration + "ms");

  410.         var ok = _safeDispatchGesture([pL, pR]);
  411.         _log(ok ? "✓ 水平放大执行成功" : "✗ 水平放大执行失败");
  412.         if (!ok) _gestureFailHint();
  413.         return ok;
  414.     } catch (e) {
  415.         _log("✗ 水平放大函数异常: " + e);
  416.         return false;
  417.     }
  418. }

  420. // =====================================================
  421. //  3. 主流程（无碍模式：每个示例独立 try-catch，互不影响）
  422. // =====================================================
  423. function main() {
  424.     _log("========== 双指向中间滑动（捏合手势）示例【无碍模式】 ==========");

  426.     if (!_GESTURE_OK) {
  427.         _log("✗ 环境自检未通过，跳过所有手势执行（请先开启无障碍服务权限）");
  428.         return;
  429.     }

  431.     var s = _gestureGetScreen();
  432.     var screenW = s.w, screenH = s.h;
  433.     _log("屏幕尺寸: " + screenW + " x " + screenH);

  435.     // ---------- 示例 1：水平方向双指捏合（向中间滑动，缩小图片用） ----------
  436.     _log("\n--- 示例1: 水平捏合（向中间滑动，缩小）---");
  437.     try {
  438.         var pathLeft1 = new path();
  439.         pathLeft1.setDurTime(600);
  440.         pathLeft1.addPoint(screenW * 0.25, screenH * 0.5);
  441.         pathLeft1.addPoint(screenW * 0.45, screenH * 0.5);

  443.         var pathRight1 = new path();
  444.         pathRight1.setDurTime(600);
  445.         pathRight1.addPoint(screenW * 0.75, screenH * 0.5);
  446.         pathRight1.addPoint(screenW * 0.55, screenH * 0.5);

  448.         var ok1 = _safeDispatchGesture([pathLeft1, pathRight1]);
  449.         _log(ok1 ? "✓ 水平捏合执行成功" : "✗ 水平捏合执行失败");
  450.         if (!ok1) _gestureFailHint();
  451.     } catch (e) {
  452.         _log("✗ 示例1 异常: " + e);
  453.     }
  454.     try { sleep.second(1); } catch (e) {}

  456.     // ---------- 示例 2：垂直方向双指捏合（上指下滑 + 下指上滑 → 向中间） ----------
  457.     _log("\n--- 示例2: 垂直捏合（向中间滑动）---");
  458.     try {
  459.         var pathTop = new path();
  460.         pathTop.setDurTime(600);
  461.         pathTop.addPoint(screenW * 0.5, screenH * 0.25);
  462.         pathTop.addPoint(screenW * 0.5, screenH * 0.45);

  464.         var pathBottom = new path();
  465.         pathBottom.setDurTime(600);
  466.         pathBottom.addPoint(screenW * 0.5, screenH * 0.75);
  467.         pathBottom.addPoint(screenW * 0.5, screenH * 0.55);

  469.         var ok2 = _safeDispatchGesture([pathTop, pathBottom]);
  470.         _log(ok2 ? "✓ 垂直捏合执行成功" : "✗ 垂直捏合执行失败");
  471.         if (!ok2) _gestureFailHint();
  472.     } catch (e) {
  473.         _log("✗ 示例2 异常: " + e);
  474.     }
  475.     try { sleep.second(1); } catch (e) {}

  477.     // ---------- 示例 3：对角线捏合（左上+右下同时向中心靠拢） ----------
  478.     _log("\n--- 示例3: 对角线捏合（左上+右下 → 中心）---");
  479.     try {
  480.         var pathLT = new path();
  481.         pathLT.setDurTime(700);
  482.         pathLT.addPoint(screenW * 0.15, screenH * 0.2);
  483.         pathLT.addPoint(screenW * 0.42, screenH * 0.46);

  485.         var pathRB = new path();
  486.         pathRB.setDurTime(700);
  487.         pathRB.addPoint(screenW * 0.85, screenH * 0.8);
  488.         pathRB.addPoint(screenW * 0.58, screenH * 0.54);

  490.         var ok3 = _safeDispatchGesture([pathLT, pathRB]);
  491.         _log(ok3 ? "✓ 对角线捏合执行成功" : "✗ 对角线捏合执行失败");
  492.         if (!ok3) _gestureFailHint();
  493.     } catch (e) {
  494.         _log("✗ 示例3 异常: " + e);
  495.     }
  496.     try { sleep.second(1); } catch (e) {}

  498.     // ---------- 示例 4：放大手势（与捏合相反，双指向外分开） ----------
  499.     _log("\n--- 示例4: 水平放大（双指向外分开）---");
  500.     try {
  501.         var pathLeft4 = new path();
  502.         pathLeft4.setDurTime(600);
  503.         pathLeft4.addPoint(screenW * 0.45, screenH * 0.5);
  504.         pathLeft4.addPoint(screenW * 0.20, screenH * 0.5);

  506.         var pathRight4 = new path();
  507.         pathRight4.setDurTime(600);
  508.         pathRight4.addPoint(screenW * 0.55, screenH * 0.5);
  509.         pathRight4.addPoint(screenW * 0.80, screenH * 0.5);

  511.         var ok4 = _safeDispatchGesture([pathLeft4, pathRight4]);
  512.         _log(ok4 ? "✓ 水平放大执行成功" : "✗ 水平放大执行失败");
  513.         if (!ok4) _gestureFailHint();
  514.     } catch (e) {
  515.         _log("✗ 示例4 异常: " + e);
  516.     }
  517.     try { sleep.second(1); } catch (e) {}

  519.     // ---------- 示例 5：调用封装函数 ----------
  520.     _log("\n--- 示例5: 调用封装函数 pinchHorizontal() ---");
  521.     try {
  522.         var ok5 = pinchHorizontal(0.2, 0.8, 0.5, 0.5, 800);
  523.         _log(ok5 ? "✓ 封装函数调用成功" : "✗ 封装函数调用失败（不影响脚本继续）");
  524.     } catch (e) {
  525.         _log("✗ 示例5 异常: " + e);
  526.     }
  527.     try { sleep.second(1); } catch (e) {}

  529.     // ---------- 示例 6：封装函数集合演示（垂直/对角线/放大/通用） ----------
  530.     _log("\n--- 示例6: 封装函数集合演示 ---");
  531.     try {
  532.         pinchVertical(0.2, 0.8, 0.5, 0.5, 700);
  533.         try { sleep.second(1); } catch (e) {}
  534.         pinchDiagonal(800);
  535.         try { sleep.second(1); } catch (e) {}
  536.         zoomHorizontal(700);
  537.         try { sleep.second(1); } catch (e) {}
  538.         pinchGeneric({x: 0.1, y: 0.1}, {x: 0.9, y: 0.9}, {x: 0.5, y: 0.5}, 800);
  539.     } catch (e) {
  540.         _log("✗ 示例6 异常: " + e);
  541.     }

  543.     _log("\n========== 示例全部执行完成（无碍模式） ==========");
  544. }

  546. // 执行主函数
  547. main();
复制代码



AIWROK, AIWROK软件
楼主新帖
楼主热帖
untoAIWROK双指向中间滑动捏合手势完整示例nextnocontent

相关帖子
回复

使用道具 举报

返回列表 发帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

相关导读了
    采集亚马逊正版群发工具有没有？
    Apr.20旅行X心语今天来说说YYPOST新功能的一个灵活用法，采集亚马逊商品信息，并且获得排名的软件，亚马逊现在越来越多客户做，淘宝的水是越来越清了，以前做电商的客户，现在都转战到外国，最赚钱的要数一些客户往亚马逊里堆了吧，拿我这个YYPOST的客户，最多的是采集，分析排名，刷价格，刷数量，改价，刷访问量等等技术
    企业发展B2B网站有什么东东软件可以发呢
    标题企业发展网B2B软件，现在虽然B2B网站收录不错，可愁的是心急的人们，他们太想一口吃撑胖子了，发帖宣传虽然不能像佛系那样淡定，但也不能像跑火车那般急躁对待，自己内容不收录，完全是自己操作内容问题，可以参考一下别人的内容是怎么弄的，然后自己要试着转变，而且收录这个内容，常常会变化的，不是一种规则就吃到老
    搜房天下房聊软件哪一个好呢
    本帖最后由 发帖软件 于 2019-5-22 16:15 编辑 2搜房天下群发房聊信息软件，开始本来打算做58同城的，但发一个就要一次点触验证码，这就让人没有感觉到存在的价值了吧，都是卖二手房和新房的搜房天下倒是可以发即时聊天信息，也没有发现他这个网站有啥子限制，登陆一个搜房天下账号，然后采集回来分类列表的网址，然后就一
    大家坛有没有好用的群发工具下载呢
    当你的笑容给我礼貌的招呼，大家坛全自动发帖软件，宣传推广是一场持久战，总是有一些人把软件用了一天，或是几个小时，就觉得自己付出太多了，那加进来的粉丝，或是流量，应该是和宣传多少成正比的，其实没有这么便宜的事，就像很多阅读量超过一百万的视频，或是电影，真正会在屏幕打赏的人不会超过三千，真正大额打赏给主
    群发正版软件中国塑料网
    中国塑料网群发软件YYPOST脚本下载地址，这个网站会有一个很奇怪的问题就是你在首页登陆无半个验证码，但在登陆网址登陆就会有一个验证码，所以我们灵活一些，在首页登陆就不用输入验证码了哈。网站秒收录比较高，但发的都是五金和建筑行业，先前有很多人都是发土建工程的大公司操作的，现在这个网站专为那个行业诞生的吧。
    OpenStreetMap网站正版2019年发帖工具下载
    本帖最后由 发帖软件 于 2019-5-21 11:13 编辑 OpenStreetMap网站全自动群发，OpenStreetMapOpenStreetMap（简称OSM，中文是公开地图）是一个网上地图协作计划，目标是创造一个内容自由且能让所有人编辑的世界地图。有的人编辑地图然后等收录，有的人发日志等收录，我们这里也是利用地图日志做为宣传的目标，简单的脚本理
    搜房天下全自动收短信全自动识别验证码注册账号软件
    房天下自动注册机，这个脚本是前几天发房聊的脚本廷伸品种，这个脚本能做到自动注册账号，自动保存账号，自动发房聊的效果，不过今天我们主要说一说怎么注册账号写脚本吧，这个搜房天天下的账号，可以发提问，可以发房聊，发论坛，发博客，还有发个人中心页都是有秒收的效果的，这样就省去了去买号，去乱花钱的效果了吧，而
    企业邮箱安卓端有什么APP软件可以发的呢
    请输入标题企业邮箱安卓发发送邮箱脚本，这个脚本是利用企业邮箱进行群发的，全程是一种模拟手工操作的过程，所以封号是很少的，而且企业邮箱群发到普通QQ邮箱不容易进垃圾箱中的，所以这个脚本也是这样的原理，不过最好是利用一些多开器，登陆多点的QQ邮箱账号会比较流畅一些，然后用软件一个一个的切换APP进行群发邮件会
    头条留评论软件有没有好用的呢？
    今天整一个今日头条留言软件，对于留言YYPOST是优势是比较大的存在，因为他往往专注一些下拉定位的优点，像今日头条这样，还是需要一些特殊下拉定位的，因为他新闻有长有短，有图有视频的，所以综合起来定位是比较难的，如果用POST也不是很轻松可以破解他的加密参数。这个脚本也是有一个不好的地方就是换号会比较麻烦，您电
    单网页生成神器
    最近新技术，网页生成机占领了整个网络的半壁江山，效果很疯狂，虽然不知道能持续多久，作为开发软件的领头者，一直在找收录的方法，一直在努力创新着，一直被人模仿，却从没有被超越过，这个网页生成机，已经出来有一段时间了，一直没有拿出来分享，醉过醉过，它是利用的一些小小收录漏洞整的，您最好用一些老站域名，进行
关闭
本站开发自动发帖软件是目前效果最好的发贴工具，软件可以兼容所有的论坛，进行群发贴子，可以对各大论坛自主录制操作流程，自动识别 验证码，自动注册账号，自动群发贴子，还可以设置成自动抢沙发，是推广宣传的神级软件，软件可以兼容任何IE能顶贴发贴论坛，完全可以 做成论坛发贴软件，生成脚本，对各大论坛程序完美支持的。软件不但发的贴子收录快，而且只用法简单，使用方便，价格便宜，软件客服16 小时在线全程协助，为您的宣传保驾护航。用最少的投资，实现最大的收益，用最简单的方式，完全最复杂的操作。 QQ

Copyright © 2014 ( 京ICP备09078825号 )

Powered by Discuz! X3.2

群发软件发帖工具
快速回复 返回列表 返回顶部
本站自动发贴软件，是现在最流行的做脚本软件，这种发贴工具，不但发贴收录快，而且抢占好的先机，完全自由编辑，实现针对性群发模拟操作，软件可以顶贴，也可以发贴，可以兼容支持Discuz、PHPWind、Dvbbs三大主流论坛，有手机验证码收件，邮件收发的功能，支持验证码识别，注册问题识别，多线程任务，自动上传头像，自动激活注册邮件，兼容防注册插件，本站软件原创正版，更新效率最快的原创软件。 『网络推广软件』『自动发帖软件』『 自动发帖』