自动化能力

• 无障碍控件自动化（推荐）
  • 基于控件选择器查找与操作（点击/长按/滑动/输入等）
  • 适配性好：对不同分辨率与机型更稳定
  • 相关文档：/v8/automator/
• 坐标与手势自动化
  • 适合游戏、画面类 UI 或无法被无障碍识别的界面
  • 支持点击/滑动/多点手势、RootAutomator 等
  • 相关文档：/v8/coordinatesBasedAutomation
• 按键与系统导航
  • 模拟返回/主页/通知栏/最近任务等（无障碍或 root）
  • 相关文档：/v8/keys

UI（原生 UI）能力

• Rhino UI 模块（v8）
  • 使用 XML 方式声明界面："ui"; + $ui.layout(...)
  • 在 UI 线程更新控件：$ui.post() / $ui.run()
  • 相关文档：/v8/ui
• 自定义组件 / 自定义控件
  • 通过 $ui.registerWidget() 封装可复用组件，支持属性/事件/方法
  • 相关文档：/v8/ui/customWidget
• WebView / Web 技术写 UI
  • 在 UI 中嵌入 WebView，加载本地/远程页面并与脚本通信
  • 相关文档：/v8/ui/webview

多线程与并发

• threads 模块
  • 子线程执行耗时任务，避免阻塞 UI/主线程
  • 线程间协作与事件机制（视版本与模块而定）
  • 相关文档：/v8/threads

定时任务与后台运行

• 定时任务（WorkManager）
  • 每日/每周/一次性/Intent 触发等任务类型
  • 适合定时执行、保活场景的任务调度
  • 相关文档：/v8/timedTasks
• 电源管理与忽略电池优化
  • 检测/请求忽略电池优化，提高后台稳定性（注意电量影响）
  • 相关文档：/v8/powerManager
• 内部开关设置
  • 例如“音量上键停止脚本”、前台服务通知等
  • 相关文档：/v8/settings

网络与实时通信

• HTTP / WebSocket
  • 基于 OkHttp 的网络能力（请求构建、响应处理等）
  • WebSocket 适用于实时双向通信、推送与长连接
  • 相关文档：/v8/http、/v8/webSocket

图片与视觉能力

• images 模块（截图、找色、找图、特征匹配等）
  • 截图、读写图片、裁剪/缩放/旋转/滤镜
  • 找色/找图/模板匹配/特征点等能力（以具体版本文档为准）
  • 相关文档：/v8/images
• OCR（文字识别）
  • 插件式 OCR（如 PaddleOCR / MLKitOCR 等），用于图片文字识别
  • 相关文档：/v8/ocr

插件生态

• 插件商店
  • 安装/管理官方与第三方插件（OCR、7Zip、FFmpeg 等）
• 插件 SDK（高级能力）
  • 可开发并加载自定义插件，提供更强的原生扩展能力
  • 相关文档：/v8/plugins、/v8/thirdPartyPlugins

文件系统与数据存储

• files 模块
  • 常用读写、复制移动、路径处理、文本/字节读写、打开文件句柄等
  • 相关文档：/v8/files
• storages 本地存储
  • 脚本间共享的持久化 KV 存储（不适合存敏感信息）
  • 相关文档：/v8/storages

打包发布与工程化

• 工程打包
  • 支持工程/脚本打包为独立 APK（具体能力以版本与配置为准）
• 资源与 Android 原生资源集成（UI）
  • 在 UI 中使用 res/ 资源、样式等（参见 UI API 文档）
  • 相关文档：/v8/ui/api
• 加密与代码保护（增强能力）
  • 结合打包与工具链提供更强的保护（不同引擎能力不同）

调试与开发体验

• 控制台与日志
  • console.*、toastLog 等输出与交互能力
  • 相关文档：/v8/console
• VSCode 调试
  • 更接近工程化的调试体验（视版本与配置而定）
  • 相关文档：新版VSCode调试教程

版本差异提示（v8 vs v9）

• v8：以 Rhino UI 与 v8 API 文档为主，适合快速脚本与 UI 开发。
• v9：引入 Node.js 引擎（16.x） 等增强能力，生态与工程化能力更强（以 v9 文档为准），但是存在内存泄露问题，不推荐使用。

0. 必要前提（必须遵守）

1. UI 脚本必须以 "ui"; 开头
   • "ui"; 必须在第一行，不能有代码在它前面。
2. 布局必须用 ui.layout(...) 包裹
3. 所有 UI 更新必须在 UI 线程执行
   • 子线程需要更新界面时，使用 $ui.post(...) 或 $ui.run(...)。
4. 颜色统一使用 #RRGGBB
5. 透明度使用 alpha 范围 0 ~ 1，0 全透，1 全不透明。
   • <text id="title" text="标题" alpha="0.6"/>
   • $ui.title.setAlpha(0.6)
   • $ui.title.attr('alpha', '0.6')

1. 文件与结构约定（推荐）

• 单文件脚本结构（从上到下固定顺序）：
  • "ui";
  • 常量区（颜色、间距、字号、字符串）
  • ui.layout(<xml>...</xml>)（或 $ui.layout(...)）布局区
  • const view = {...} 视图引用区（集中获取 ui.xxx）
  • 事件绑定区（点击、输入、滚动等）
  • 业务逻辑区（网络/IO/计算放子线程）
• 复杂界面：优先拆为“组件/子布局”（见 3.6），避免一个超长 XML。

2. 术语与命名规范

2.1 控件 id 命名

• 必须有意义：表达用途而不是外观。
• 风格统一：推荐 camelCase。
• 避免冲突：不要使用可能与 ui 现有属性冲突的名字（如 layout、post、run 等）。冲突时用 $ui.findView(id) 获取。

示例：

• 好：titleText、submitBtn、searchInput、list、emptyView
• 不建议：text1、button2、redBtn

2.2 事件处理函数命名

• 推荐 onXxx / handleXxx：
  • onSubmitClick、handleSearchChange、onItemLongClick

3. XML 布局规范

3.1 基本规则

• 布局必须清晰：优先使用 vertical / horizontal / frame / scroll 组合，减少不必要的嵌套层级。
• 尽量声明式：优先在 XML 描述结构与静态样式；仅在确有必要时再动态 inflate/addView。
• 属性显式化：对关键体验属性（padding、margin、textSize、textColor、bg）不要依赖默认值。

3.2 间距与尺寸（dp/sp）

• 文字字号：使用 sp（如 14sp、16sp、20sp）。
• 间距/尺寸：使用 dp（如 8dp、12dp、48dp）。
• 触控目标：可点击控件的最小高度/宽度建议不小于 (48dp)。

3.3 颜色与对比度

• 统一颜色来源：把常用颜色集中到常量区，避免散落魔法值。
• 对比度优先：正文文字与背景需有足够对比，浅底用深字、深底用浅字。
• 状态色一致：成功/警告/错误/禁用的颜色语义要稳定，不要同一颜色表达多个含义。

3.4 字体与排版

• 正文：默认 14sp~16sp，行高（如果可控）保持舒适，不要挤压。
• 标题：18sp~22sp，可配合加粗（如果控件/样式支持）。
• 对齐：同一层级元素对齐方式保持一致，优先左对齐。

3.5 可滚动区域

• 滚动容器只包需要滚动的内容，避免整页嵌套多层滚动。
• 列表场景优先用 list 组件（如有），不要用大量动态创建 View 模拟长列表。

3.6 组件化与复用（推荐）

• 可复用块建议抽为：
  • 自定义控件：$ui.registerWidget(name, widget)
  • 子布局：使用 $ui.inflate(xml, parent, attachToParent) 注入到容器
• 复用时保持：
  • 输入/输出清晰（属性/回调）
  • 不依赖外部全局变量（或明确依赖）

4. JavaScript/线程规范

4.1 UI 线程原则

• 禁止在 UI 线程执行：
  • 网络请求
  • 文件 IO
  • 大量循环/计算
  • 批量创建/更新大量 View
• 子线程完成后，通过 $ui.post(() => { ... }) 回到 UI 线程更新界面。

4.2 更新 UI 的推荐方式

• 简单异步更新：$ui.post(callback[, delay])
• 需要拿到返回值且允许阻塞当前线程：$ui.run(callback)

5. 交互规范（必须有一致性）

5.1 点击与反馈

• 点击必须有反馈（系统点击态/涟漪、文本变化、loading 等其一）。
• 提交类按钮在请求中应进入 loading/disabled，避免重复提交。

5.2 输入与校验

• 输入框应提供：
  • 合理的提示文案（placeholder/hint）
  • 必要的格式限制与实时校验（如手机号/验证码长度）
  • 错误提示靠近输入框，文案明确可执行

5.3 空态 / 错误态 / 加载态（必备三态）

每个“列表/内容区”至少考虑：

• 加载态：首屏加载中
• 空态：无数据/无权限/条件筛选无结果
• 错误态：网络失败/接口错误/解析错误（提供重试入口）

6. 可访问性（A11y）与可用性

• 文字可读：避免低对比度与过小字号。
• 可点击区域足够大：小图标需加 padding 扩大触控区域。
• 信息不只靠颜色：错误提示除红色外应有文案/图标。

7. 性能与稳定性红线

• 不要用 for 循环动态 inflate 上百个 View 组成列表；用列表组件或分页渲染。
• 避免频繁全量刷新：仅更新变化的控件（如只改 text、visibility）。
• 图片：
  • 网络图要考虑缓存与失败占位（如适用）
  • 必要时使用 $ui.imageCache.clearMemory() / $ui.imageCache.clearDiskCache()（注意其线程行为）

8. XML 中使用变量（重要）

在 ui.layout(<xml>...</xml>) 的 XML 里可以嵌入 JavaScript 表达式，用于复用常量或条件渲染（以实际运行环境支持为准）。建议遵守：

• 变量来自“常量区”：如 COLORS、SIZES，避免到处随意声明。
• 表达式保持简单：不要在 XML 里写复杂逻辑，复杂逻辑放到布局之后用 JS 更新属性。

示例（仅示意）：

"ui";

const COLORS = {
  bg: "#FFFFFF",
  primary: "#009688",
  text: "#222222",
};

$ui.layout(
  <vertical bg="{{COLORS.bg}}" padding="16dp">
    <text
      id="titleText"
      text="示例标题"
      textColor="{{COLORS.text}}"
      textSize="20sp"
    />
    <button
      id="submitBtn"
      text="提交"
      style="Widget.AppCompat.Button.Colored"
    />
  </vertical>,
);

9. 推荐模板（可直接复用）

"ui";

const COLORS = {
  bg: "#FFFFFF",
  text: "#222222",
  subText: "#666666",
  primary: "#009688",
  danger: "#E53935",
};

$ui.layout(
  <vertical bg="{{COLORS.bg}}" padding="16dp">
    <text
      id="titleText"
      text="页面标题"
      textSize="20sp"
      textColor="{{COLORS.text}}"
    />

    <input id="searchInput" hint="请输入关键字" marginTop="12dp" />

    <button id="submitBtn" text="搜索" marginTop="12dp" />

    <text
      id="statusText"
      text="就绪"
      marginTop="12dp"
      textSize="14sp"
      textColor="{{COLORS.subText}}"
    />
  </vertical>,
);

ui.submitBtn.on("click", () => {
  ui.statusText.attr("text", "加载中…");
  ui.submitBtn.attr("enabled", false);

  // 模拟耗时任务：真实项目把网络/IO/计算放子线程
  // 开启子线程
  threads.start(() => {
    // 模拟耗时操作
    java.lang.Thread.sleep(2500);

    // 更新UI必须用 ui.post
    ui.post(() => {
      ui.statusText.setText("耗时任务执行完毕 ✅");
      ui.submitBtn.attr("enabled", true);
    });
  });
});

10. 发布前检查清单（建议逐项过）

• 模式：脚本第一行是 "ui";，且之前无任何代码
• 线程：所有 UI 更新都在 UI 线程（子线程通过 $ui.post/$ui.run 回来）
• 三态：主要内容区有加载/空/错误态
• 适配：不同屏幕尺寸下不遮挡、不溢出、可滚动区域正确
• 可用性：主要按钮触控面积 (\ge 48dp)，无重复提交
• 一致性：颜色、字号、间距不乱；命名清晰无冲突

使用规则：

• 默认版本：v8
• UI 脚本第一行必须是 "ui";
• 普通脚本不要写 "nodejs";
• 变量声明使用 let 或 var，不要使用 const（Rhino 兼容问题）
• 需要权限的示例要先检查权限，再执行动作
• 长耗时任务不要阻塞 UI 线程

相关文档：

• v8 文档首页
• UI 模块
• 悬浮窗
• 无障碍选择器
• 图片与图色处理
• Java 交互

1. 普通脚本基础模板

适合：日志、提示、顺序执行、简单任务。

toast("脚本开始");
console.log("device:", device.brand, device.model);

try {
  sleep(500);
  toastLog("任务完成");
} catch (e) {
  console.error(e);
  toast("脚本出错: " + e);
}

常见修改点：

• 把核心逻辑放到 try 中，方便定位错误
• 需要调试时优先用 console.log() / toastLog()

2. UI 最小模板

适合：带按钮、输入框、状态文本的小工具。

"ui";

$ui.layout(
  <vertical padding="16">
    <text text="Auto.js Pro v8 UI 示例" textSize="18sp" />
    <input id="name" hint="请输入名字" />
    <button id="hello" text="打招呼" />
    <text id="status" text="等待操作" />
  </vertical>,
);

$ui.hello.on("click", () => {
  let name = String($ui.name.text() || "Auto.js Pro");
  $ui.status.setText("Hello, " + name);
  toast("已更新界面");
});

常见错误：

• 不要在点击事件中直接写 while (true) 或长时间 sleep()
• 子线程更新 UI 时需要回到 UI 线程，例如 $ui.run(() => { ... })

3. 常用 UI 控件组合

适合：设置页、表单、小型工具面板。

"ui";

$ui.layout(
  <scroll>
    <vertical padding="16">
      <text text="任务设置" textSize="20sp" textStyle="bold" />
      <input id="keyword" hint="关键字" />
      <checkbox id="enableLog" text="启用日志" checked="true" />
      <radiogroup id="mode">
        <radio id="fast" text="快速模式" checked="true" />
        <radio id="safe" text="稳定模式" />
      </radiogroup>
      <spinner id="interval" entries="1秒|3秒|5秒" />
      <button id="save" text="保存配置" />
    </vertical>
  </scroll>,
);

$ui.save.on("click", () => {
  let config = {
    keyword: String($ui.keyword.text()),
    enableLog: $ui.enableLog.checked,
    mode: $ui.fast.checked ? "fast" : "safe",
    intervalIndex: $ui.interval.getSelectedItemPosition(),
  };
  toastLog(JSON.stringify(config));
});

AI 生成 UI 时应优先选择这些基础控件，除非用户明确要求复杂列表、WebView 或自定义控件。

4. 悬浮窗控制按钮

适合：悬浮启动/停止按钮、脚本控制面板、辅助工具入口。

if (!floaty.checkPermission()) {
  let ok = confirm("悬浮窗权限", "请先授予悬浮窗权限，然后重新运行脚本");
  if (!ok) {
    exit();
  }
  floaty.requestPermission();
  exit();
}

let window = floaty.window(
  <frame>
    <button id="action" text="开始" w="90" h="40" bg="#77ffffff" />
  </frame>,
);

window.setPosition(100, 300);
window.exitOnClose();

let running = false;

window.action.click(() => {
  running = !running;
  window.action.setText(running ? "停止" : "开始");
  toast(running ? "任务已开始" : "任务已停止");
});

window.action.longClick(() => {
  window.setAdjustEnabled(!window.isAdjustEnabled());
  return true;
});

// 保持脚本运行，否则悬浮窗会随脚本结束而关闭。
setInterval(() => {}, 1000);

注意事项：

• floaty.requestPermission() 只会跳转到授权页面，不会阻塞等待授权结果
• 长按按钮切换调整模式，便于移动悬浮窗

UI 模式下优雅申请悬浮窗权限

适合：脚本本身有主界面，需要引导用户去系统设置页打开悬浮窗权限，并在用户返回时自动复查状态。

"ui";

function checkAndRequestFloaty() {
  if (floaty.checkPermission()) {
    return true;
  }

  $dialogs.setDefaultDialogType("app");
  dialogs
    .build({
      title: "需要悬浮窗权限",
      content:
        "为了显示悬浮控制台，请在随后的设置页中找到本应用并开启“允许显示在其他应用上”。",
      positive: "去开启",
      negative: "取消",
      cancelable: false,
    })
    .on("positive", function () {
      floaty.requestPermission();
      toast("请找到本应用并开启悬浮窗开关");
    })
    .on("negative", function () {
      toast("未授予权限，悬浮窗功能不可用");
    })
    .show();

  return false;
}

$ui.layout(
  <vertical padding="16">
    <text text="脚本主界面" textSize="20sp" gravity="center" margin="20" />
    <button
      id="start"
      text="开始运行"
      style="Widget.AppCompat.Button.Colored"
    />
  </vertical>,
);

ui.emitter.on("resume", function () {
  if (checkAndRequestFloaty()) {
    toastLog("悬浮窗权限已就绪");
  }
});

checkAndRequestFloaty();

$ui.start.click(function () {
  if (checkAndRequestFloaty()) {
    toast("权限已开启，正在启动...");
  }
});

说明：

• UI 模式下不要用阻塞式等待权限的写法，应使用对话框引导用户操作
• $dialogs.setDefaultDialogType("app") 让对话框以应用内对话框显示，避免还没拿到悬浮窗权限时对话框也依赖悬浮窗
• ui.emitter.on("resume", ...) 用于监听用户从设置页返回，再次检查权限
• 用户取消时不要强制继续创建悬浮窗，应禁用相关功能或提示重新授权

5. Java / Android API 调用

适合：打开系统页面、调用 Android 类、实现更底层能力。

importClass(android.content.Intent);
importClass(android.provider.Settings);
importClass(android.net.Uri);

let intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
intent.setData(Uri.parse("package:" + context.getPackageName()));
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent);

let builder = new java.lang.StringBuilder();
builder.append("package=");
builder.append(context.getPackageName());
console.log(builder.toString());

UI 中实现 Java 点击监听：

"ui";

$ui.layout(
  <vertical padding="16">
    <button id="btn" text="Java Listener" />
  </vertical>,
);

let listener = new android.view.View.OnClickListener(function (view) {
  toast("clicked by Java listener");
});

$ui.btn.setOnClickListener(listener);

注意事项：

• v8 使用 Rhino，可直接访问 android.*、java.* 等包
• 非常见包可通过 Packages.xxx 访问
• UI 示例仍必须把 "ui"; 放在第一行

6. 文件、存储与 HTTP

适合：保存配置、读取本地文件、调用接口。

let storage = storages.create("demo_config");
storage.put("token", "example-token");
storage.put("enabled", true);

let dir = "/sdcard/autojs";
let file = files.join(dir, "log.txt");

files.ensureDir(dir);
files.append(file, new Date().toISOString() + " script started\n");

let response = http.get("https://httpbin.autojs.run/get");
if (response.statusCode !== 200) {
  throw new Error("HTTP 请求失败: " + response.statusCode);
}

let data = JSON.parse(response.body.string());
console.log("origin:", data.origin);
console.log("token:", storage.get("token"));

常见组合：

• UI 表单读取用户输入后写入 storages
• 脚本启动时读取配置，再执行自动化任务
• HTTP 请求失败时写入日志，方便排查

7. UI + 子线程任务

适合：按钮启动耗时任务、后台轮询、执行 HTTP / 文件读写后更新界面。

"ui";

$ui.layout(
  <vertical padding="16">
    <text text="UI + 子线程任务" textSize="18sp" />
    <text id="status" text="状态：等待开始" />
    <horizontal>
      <button id="start" text="开始任务" />
      <button id="stop" text="停止任务" />
    </horizontal>
  </vertical>,
);

let running = false;
let worker = null;

$ui.start.on("click", function () {
  if (running) {
    toast("任务正在运行");
    return;
  }

  running = true;
  $ui.status.setText("状态：运行中");

  worker = threads.start(function () {
    try {
      for (let i = 1; i <= 5 && running; i++) {
        sleep(1000);

        let progressText = "状态：进度 " + i + "/5";
        $ui.run(function () {
          $ui.status.setText(progressText);
        });
      }

      $ui.run(function () {
        $ui.status.setText(running ? "状态：任务完成" : "状态：已停止");
      });
    } catch (e) {
      $ui.run(function () {
        $ui.status.setText("状态：出错 - " + e.message);
      });
      console.error(e);
    } finally {
      running = false;
    }
  });
});

$ui.stop.on("click", function () {
  running = false;
  $ui.status.setText("状态：正在停止...");
});

注意事项：

• running 用于协作停止，让子线程在下一轮循环时退出
• 不要直接从子线程调用 $ui.status.setText(...)
• 网络请求、截图识别、大文件读写都适合放进 threads.start(...)
• 如果任务很复杂，应把核心逻辑封装成函数，UI 事件只负责启动、停止和显示状态

8. UI + 本地配置

适合：设置页、账号参数、开关选项、脚本启动时恢复上次配置。

"ui";

let storage = storages.create("ai_v8_settings_demo");

$ui.layout(
  <vertical padding="16">
    <text text="本地配置示例" textSize="18sp" />
    <input id="keyword" hint="关键字" />
    <input id="delay" inputType="number" hint="延迟毫秒，例如 1000" />
    <checkbox id="enableLog" text="启用日志" />
    <horizontal>
      <button id="save" text="保存" />
      <button id="load" text="读取" />
      <button id="reset" text="重置" />
    </horizontal>
    <text id="status" text="状态：等待操作" />
  </vertical>,
);

function loadConfig() {
  let keyword = storage.get("keyword", "");
  let delay = storage.get("delay", 1000);
  let enableLog = storage.get("enableLog", true);

  $ui.keyword.setText(String(keyword));
  $ui.delay.setText(String(delay));
  $ui.enableLog.checked = !!enableLog;
  $ui.status.setText("状态：配置已读取");
}

function saveConfig() {
  let delay = parseInt(String($ui.delay.text()), 10);
  if (isNaN(delay) || delay < 0) {
    toast("延迟必须是大于等于 0 的数字");
    return;
  }

  let config = {
    keyword: String($ui.keyword.text()),
    delay: delay,
    enableLog: $ui.enableLog.checked,
  };

  storage.put("keyword", config.keyword);
  storage.put("delay", config.delay);
  storage.put("enableLog", config.enableLog);

  $ui.status.setText("状态：已保存 " + JSON.stringify(config));
  toast("配置已保存");
}

$ui.save.on("click", saveConfig);
$ui.load.on("click", loadConfig);
$ui.reset.on("click", function () {
  storage.clear();
  $ui.keyword.setText("");
  $ui.delay.setText("1000");
  $ui.enableLog.checked = true;
  $ui.status.setText("状态：已重置");
});

// 启动时自动恢复上次配置。
loadConfig();

注意事项：

• storages.create(name) 的 name 应固定，方便下次启动读取同一份配置
• input 读取到的是文本，数字参数要用 parseInt() / parseFloat() 转换并校验
• 不要把密码、Token 等敏感信息明文写进文档示例；真实项目应提醒用户自行保护
• UI 初始化完成后再调用 loadConfig()，确保控件已经存在

给 AI 的固定提示词

可以把下面这段贴给 AI，减少版本混淆：

请使用 Auto.js Pro v8（第一代 API / Rhino）生成代码。
如果是 UI 脚本，第一行必须是 "ui";。
不要使用 v9 / Node.js 的 require、async API 或 "nodejs";。
变量声明请使用 let 或 var，不要使用 const。
需要权限的能力（无障碍、悬浮窗、截图）必须先检查或请求权限。
请优先给出最小可运行代码，并说明需要修改的参数。

1. 插件信息

免责声明：本插件以及本博客内容均由第三方提供，请您仔细甄别后再下载和使用。若插件有任何侵权、病毒或其他违法行为，请联系我方下架。

作者：LZX284

基于 p7zip 16.02 制作，支持多种格式文件的压缩与解压，安装后即可使用。
支持的 API 架构：armeabi-v7a, arm64-v8a, x86, x86_64

下载地址： https://wwwq.lanzouc.com/iyQIl167x38j

从 Pro 9.2 开始，打包时插件可被合并到 apk 中，打包后无需再安装插件即可使用。

2. 用法示例

解压

javascript

let P7zip = $plugins.load("cn.lzx284.p7zip");
let mP7zip = new P7zip();

// 源路径(目录或文件皆可，必须是完整路径)
let srcPath = "/storage/emulated/0/脚本/";
// 目标目录(必须是完整路径)
let dirPath = "/storage/emulated/0/";
// 压缩类型
// 支持的压缩类型包括: zip 7z bz2 bzip2 tbz2 tbz gz gzip tgz tar wim swm xz txz。
let type = "7z";
// 压缩等级: 0-9。
let level = 0;
// 压缩密码（注意，在p7zip中，类似""这样的空字符也算是密码的一种，与没有密码不一样）
let password = "password";
// 压缩文件路径(必须是完整路径)
let compressedFile = "/storage/emulated/0/test." + type;
let rarFile = files.path("./test.rar"); // rar格式仅支持解压缩
let cmdStr = "7z x -y -aos -p" + password + " -o" + dirPath + " " + rarFile;

// 支持的解压缩类型包括：zip、7z、bz2、bzip2、tbz2、tbz、gz、gzip、tgz、tar、wim、swm、xz、txz以及rar、chm、iso、msi等众多格式。
// p7zip解压(若文件已存在则跳过)
// 无密码解压：mP7zip.extract(compressedFile, dirPath)
switch (mP7zip.extract(compressedFile, dirPath, password)) {
  case 0:
    toastLog("解压缩成功！请到 " + dirPath + " 目录下查看。");
    break;
  case 1:
    toastLog("压缩结束，存在非致命错误（例如某些文件正在被使用，没有被压缩）");
    break;
  case 2:
    toastLog("致命错误");
    break;
  case 7:
    toastLog("命令行错误");
    break;
  case 8:
    toastLog("没有足够内存");
    break;
  case 255:
    toastLog("用户中止操作");
    break;
  default:
    toastLog("未知错误");
}

压缩

javascript

let P7zip = $plugins.load("cn.lzx284.p7zip");
let mP7zip = new P7zip();

// 源路径(目录或文件皆可，必须是完整路径)
let srcPath = "/storage/emulated/0/脚本/";
// 目标目录(必须是完整路径)
let dirPath = "/storage/emulated/0/";
// 压缩类型
// 支持的压缩类型包括: zip 7z bz2 bzip2 tbz2 tbz gz gzip tgz tar wim swm xz txz。
let type = "7z";
// 压缩等级: 0-9。
let level = 0;
// 压缩密码（注意，在p7zip中，类似""这样的空字符也算是密码的一种，与没有密码不一样）
let password = "password";
// 压缩文件路径(必须是完整路径)
let compressedFile = "/storage/emulated/0/test." + type;
let rarFile = files.path("./test.rar"); // rar格式仅支持解压缩
let cmdStr = "7z x -y -aos -p" + password + " -o" + dirPath + " " + rarFile;

// p7zip压缩(若文件已存在则跳过)
// 无密码压缩：mP7zip.add(type, level, srcPath, compressedFile)
switch (mP7zip.add(type, level, srcPath, compressedFile, password)) {
  case 0:
    toastLog("压缩成功！文件已保存为： " + compressedFile);
    break;
  case 1:
    toastLog("压缩结束，存在非致命错误（例如某些文件正在被使用，没有被压缩）");
    break;
  case 2:
    toastLog("致命错误");
    break;
  case 7:
    toastLog("命令行错误");
    break;
  case 8:
    toastLog("没有足够内存");
    break;
  case 255:
    toastLog("用户中止操作");
    break;
  default:
    toastLog("未知错误");
}

自定义命令

javascript

let P7zip = $plugins.load("cn.lzx284.p7zip");
let mP7zip = new P7zip();

// 源路径(目录或文件皆可，必须是完整路径)
let srcPath = "/storage/emulated/0/脚本/";
// 目标目录(必须是完整路径)
let dirPath = "/storage/emulated/0/";
// 压缩类型
// 支持的压缩类型包括: zip 7z bz2 bzip2 tbz2 tbz gz gzip tgz tar wim swm xz txz。
let type = "7z";
// 压缩等级: 0-9。
let level = 0;
// 压缩密码（注意，在p7zip中，类似""这样的空字符也算是密码的一种，与没有密码不一样）
let password = "password";
// 压缩文件路径(必须是完整路径)
let compressedFile = "/storage/emulated/0/test." + type;
let rarFile = files.path("./test.rar"); // rar格式仅支持解压缩
let cmdStr = "7z x -y -aos -p" + password + " -o" + dirPath + " " + rarFile;

// 自定义命令:解压加密的rar压缩文件
switch (mP7zip.cmdExec(cmdStr)) {
  case 0:
    toastLog("解压缩成功！请到 " + dirPath + " 目录下查看。");
    break;
  case 1:
    toastLog("压缩结束，存在非致命错误（例如某些文件正在被使用，没有被压缩）");
    break;
  case 2:
    toastLog("致命错误");
    break;
  case 7:
    toastLog("命令行错误");
    break;
  case 8:
    toastLog("没有足够内存");
    break;
  case 255:
    toastLog("用户中止操作");
    break;
  default:
    toastLog("未知错误");
}

3. 附录（p7zip 命令行使用参考）

7z|7za 子命令 [参数开关] 压缩包 [<文件名称>|<@列表文件…>]

在方括号内的表达式(“[” 和 “]”之间的字符)是可选的。在书名号内的表达式(“<” 和 “>”之间的字符)是必须替换的表达式(而且要去掉括号)。
7-Zip 支持和 Windows 相类似的通配符：
“_”可以使用星号代替零个或多个字符。
“?”可以用问号代替名称中的单个字符。
如果只用 _，7-Zip 会将其视为任何扩展名的全部文件。

子命令

• a: 添加到压缩文件
• b: 基准测试
• d: 从档案中删除文件
• e: 解压档案文件 (无目录名称)
• l: 列出压缩文件内容
• t: 测试压缩文件的完整性
• u: 更新文件到压缩文件中
• x: 完整路径下解压文件

参数开关

• -ai[r[-|0]]{@列表文件|!通配符}: 包括 压缩文件
• -ax[r[-|0]]{@列表文件|!通配符}: 排除 压缩文件
• -bd: 禁用百分比显示功能
• -i[r[-|0]]{@列表文件|!通配符}: 包括 文件名称
• -m<参数>，关于它有许多参数及指令，这里仅介绍简单且常用的用法。
  -m0=<压缩算法> 默认使用 lzma
  -md=<字典大小> 设置字典大小,例如 -md=32m
  -mfb=64 number of fast bytes for LZMA = 64
  -ms=<on|off> 是否固实压缩
  -mx=<19> 压缩级别-m0=压缩算法 默认使用 lzma
  -mx=数字 19 压缩级别
• -o{目录}: 设置输出目录
• -p{密码}: 设置密码
• -r[数字]: 递归子目录，使用数字定义递归子目录的深度
• -scs{UTF-8 | WIN | DOS}: 设置列表文件的编码格式
• -sfx[{名称}]: 创建 SFX 自解压文件
• -si[{名称}]: 从 stdin(标准输入设备)读取数据
• -slt: 为 l (列表) 命令显示技术信息
• -so: 将数据写入 stdout(标准输出设备)
• -ssc[-]: 设置大小写区分模式
• -ssw: 压缩共享文件
• -t{类型}: 设置压缩文件格式，(7z, zip, gzip, bzip2 or tar. 7z 是默认的格式)
• -v{大小}[b|k|m|g]: 分卷压缩
• -u[-][p#][q#][r#][x#][y#][z#][!新建档案_名称]: 更新选项
• -w[{路径}]: 指定工作目录，路径为空时代表临时文件夹目录
• -x[r[-|0]]]{@列表文件|!通配符}: 排除 文件名称
• -y: 所有询问选是

退出代码

• 0 ：正常，没有错误
• 1 ：警告，没有致命的错误，例如某些文件正在被使用，* 没有被压缩
• 2 ：致命错误
• 7 ：命令行错误
• 8 ：没有足够的内存
• 255 ：用户中止了操作

开源地址

已过期 GitHub：p7zip_autojs_plugin

注意: Auto.js Pro 的加密并不包括对代码的混淆，建议在使用自带加密前再用其他混淆工具对代码进行一次混淆。可配置编译脚本在打包时自动执行混淆，具体可参考 Pro 9.2.9 以上版本中的示例 -> 项目与打包 -> 代码混淆。

加密方式

由于 Auto.js Pro 目前有两个引擎 ———— 旧引擎 Rhino 和新引擎 Node.js。Pro 8 以前的代码均是使用 Rhino 引擎，在 Pro 9 则可在文件最前面增加”nodejs”来使用 Node.js 引擎，同时启用全新的异步 API（具体参见Pro 9 文档）。

每个引擎的加密实现方式有所不同，破解难度也会有所区别。在打包时可选择不同的加密等级，这里将说明不同加密方式的区别。

encryption-levels

Node.js 加密

还原难度：⭐️⭐️⭐️⭐️⭐️

Node.js 引擎目前只有一种加密方式，因此无论选择哪种加密等级结果没有不同。Node.js 加密的还原难度较高，推荐使用新的 Node.js 引擎来编写你的代码，文档参见第二代 API 文档。

目前 Node.js 加密方式暂不支持 mjs 文件/ES Module，这些文件不会被加密，预计在 9.5 版本支持。

使用 Node.js 加密后运行错误，请先使用不加密方式打包，若加密后报错不加密正常，则可能是以下原因：

模块文件未被识别为 nodejs 文件，被使用 Rhino 引擎方式加密，导致无法运行。

比如主模块文件是 main.node.js，require 了另一个模块文件 mod.js，但是 mod.js 文件既没有以.node.js 结尾，也没有用"nodejs";文件头，因此在加密时被当成非 nodejs 文件使用快照、dex 等加密方式加密。运行时自然会报错。

有两种方式解决：

• 所有 nodejs 文件，都以.node.js 结尾，或使用”nodejs”;`文件头
• 在 project.json 中，配置"type": "node"，则项目下的所有文件默认是 nodejs 引擎（此时 rhino 引擎的文件需要加上"rhino;"的文件头）

node_modules 下的文件未被识别为 nodejs 文件，被使用 Rhino 引擎方式加密，导致无法运行。

原理同上，推荐在 project.json 中，配置"type": "node"来解决这个问题。配置后项目下的所有文件默认是 nodejs 引擎，此时 rhino 引擎的文件需要加上"rhino;"的文件头。

在 64 位手机上加密，在 32 位手机上运行

Node.js 加密暂不支持跨 CPU 架构加密，因此只能在 64 位手机上加密只能在 64 位手机上运行；在 32 位手机上加密，CPU 架构选择 armeabi-v7a，则可以在 64 位、32 位手机上运行。

Rhino 普通加密

还原难度：⭐️

这种加密仅仅是将文件用某种方式加密，运行时需要解密，比较容易被还原。

Rhino Dex 加密

还原难度：⭐️⭐️

这种加密方式将 js 文件编译为 dex 文件，一方面提升运行效率，另一方面提高了破解门槛。但 dex 本身仍然能看出代码逻辑，推荐再使用加固或 dex2c 等方式进一步保护代码。

Rhino Snapshot 加密

还原难度：⭐️⭐️⭐️

这种加密方式将 js 文件编译为字节码文件，提升了运行效率和破解门槛。但字节码文件中的字符串等仍然为明文，因此不管使用什么加密，都推荐先使用混淆工具混淆。

加密时或加密后遇到错误

若加密过程遇到编译错误，可能是因为项目中包含 web 但 js 文件，这些文件也被参与加密导致。可以通过ignore文件将其排除加密范围，具体参见项目与配置。

插件信息

从 Pro 9.2 开始，打包时插件可被合并到 apk 中，打包后无需再安装插件即可使用。

官方 FFMpeg 插件，可调用 FFmpeg 处理音视频文件、音视频流，比如文件格式转换(视频提取音频、提取图片，mp4 转 avi 等)，视频加水印等，更多信息参见FFMpeg 百科。

本插件提供了调用 ffmpeg 命令的方法。

插件下载

64 位：
https://wwwq.lanzouc.com/icP4C167ys2j

32 位：
https://wwwq.lanzouc.com/iWzQg167ypnc

使用示例

Rhino 引擎(Pro 8 API)

// 加载ffmpeg插件
let ffmpeg = $plugins.load("org.autojs.plugin.ffmpeg");
let mp4Path = "/sdcard/input.mp4";
let mp3Path = "/sdcard/output.mp3";
// 使用ffmpeg提取文件为mp3，参见https://www.baidu.com/s?wd=ffmpeg%20%E8%A7%86%E9%A2%91%E6%8F%90%E5%8F%96mp3
let result = ffmpeg.inProcess.exec(`-i "${mp4Path}" "${mp3Path}"`);
console.log(result);

Node.js 引擎(Pro 8 API)

"nodejs";

const plugins = require("plugins");
// 加载ffmpeg插件
const ffmpeg = plugins.load("org.autojs.plugin.ffmpeg");
const mp4Path = "/sdcard/input.mp4";
const mp3Path = "/sdcard/output.mp3";
// 使用ffmpeg提取文件为mp3，参见https://www.baidu.com/s?wd=ffmpeg%20%E8%A7%86%E9%A2%91%E6%8F%90%E5%8F%96mp3
const result = ffmpeg.inProcess.exec(`-i "${mp4Path}" "${mp3Path}"`);
console.log(result);

插件信息

从 Pro 9.2 开始，打包时插件可被合并到 apk 中，打包后无需再安装插件即可使用。

官方 MLKitOCR 模块，下载后需要安装才可使用，打包时可合并到安装包中无需再安装插件才能运行，需要 Pro 9.2.11 以上版本。

基于谷歌 MLKit，识别速度超过绝大部分 OCR。

插件下载

蓝奏云下载：
https://wwwq.lanzouj.com/imA9Y168krsb

使用示例

Rhino 引擎(Pro 8 API)

// 加载OCR插件，需要先下载官方MLKitOCR插件
let MLKitOCR = $plugins.load("org.autojs.autojspro.plugin.mlkit.ocr");
let ocr = new MLKitOCR();

requestScreenCapture();

for (let i = 0; i < 5; i++) {
  let capture = captureScreen();

  // 检测截图文字并计算检测时间，首次检测的耗时比较长
  // 检测时间取决于图片大小、内容、文字数量
  let start = Date.now();
  let result = ocr.detect(capture);
  let end = Date.now();
  console.log(result);

  toastLog(`第${i + 1}次检测: ${end - start}ms`);
  sleep(3000);
}

ocr.release();

Node.js 引擎(Pro 9 API)

"nodejs";

const plugins = require("plugins");
const { requestScreenCapture } = require("media_projection");
const { showToast } = require("toast");
const { delay } = require("lang");

async function main() {
  // 加载OCR插件，需要先在Auto.js Pro的插件商店中下载官方MLKitOCR插件
  const MLKitOCR = await plugins.load("org.autojs.autojspro.plugin.mlkit.ocr");

  // 创建OCR对象
  const ocr = new MLKitOCR();
  const capturer = await requestScreenCapture();
  for (let i = 0; i < 5; i++) {
    const capture = await capturer.nextImage();

    // 检测截图文字并计算检测时间，首次检测的耗时比较长
    // 检测时间取决于图片大小、内容、文字数量
    const start = Date.now();
    const result = await ocr.detect(capture);
    const end = Date.now();
    console.log(result);

    showToast(`第${i + 1}次检测: ${end - start}ms`);
    await delay(3000);
  }
}

main().catch(console.error);

运行脚本前，我们往往需要用户开启一些必须的权限。由于用户水平不同，造成部分人群使用困难，甚至不知道需要先开启权限，这与无障碍权限“以人为本”的初衷相违背，因此我们需要一个直观的引导界面，以及方便的跳转方案，降低沟通成本，提升用户使用体验。

解决思路

1）枚举常见权限

2）获取权限状态

3）开启或跳转到权限开启界面

4）将权限状态与ui界面关联互动

具体步骤

我们运行脚本，常见的权限主要有无障碍服务、悬浮窗权限、前台服务、无障碍稳定模式、截图权限、查看使用统计权限、后台弹出权限（小米手机的miui系统），下面将对这7个权限的状态和开启办法逐一进行讨论。

无障碍服务

无障碍服务是否开启可以通过auto.service或auto.rootInActiveWindow获取，开启方式在上一篇博客中已经进行了详细的介绍，这里不再赘述。

悬浮窗权限

悬浮窗权限的判断autojspro已经有封装好的方法，可以直接用floaty.checkPermission()的返回值进行判断，此权限的跳转，这里介绍两种方法，一种是autojspro自带的基于context.startActivity封装的floaty.requestPermission()，用起来比较简单。另外介绍一种基于activity.startActivityForResult()封装的方法，可以在activity结束的回调里进行自己的操作，相对复杂，但是一些情形下用起来比较方便，同时也可以初步学习activity.startActivityForResult()的用法，不仅可以用在权限获取，在媒体库选取等方面也同样适用。这里仅展示原理以及相关代码，不做过多细致的讲解。

使用activity.startActivityForResult()有两个核心部分，一个发起带有标记的intent，另一个接收此标记的监听。

let mIntent = app.intent({
    action: "android.settings.action.MANAGE_OVERLAY_PERMISSION",
    data: "package:" + context.getPackageName(),
});
//这里把数字1作为标记
activity.startActivityForResult(mIntent, 1);
activity.getEventEmitter().on("activity_result", (requestCode, resultCode, data) => {
    if (requestCode == 1) {
        //requestCode为1说明是跳转到开启悬浮窗权限的activity结束的回调
        toast(floaty.checkPermission());
        //这里可以进行ui界面的同步
    }
});

前台服务

前台服务的开启和查询，官方的Settings模块都进行了很好地封装，我们可以直接使用。

查询是否开启前台服务：$settings.isEnabled(‘foreground_service’)

设置开启前台服务：$settings.setEnabled(‘foreground_service’, true);

无障碍稳定模式

无障碍有一个稳定模式，使用场景不多，这里可以看安卓文档AccessibilityServiceInfo里的相关说明，大致意思就是不访问不重要的视图。

稳定模式的查询可以通过$settings.isEnabled('stable_mode')来查询。

设置开启稳定模式：$settings.setEnabled(‘stable_mode’, true);

截图权限

目前新版的autojspro的images模块也支持了截图权限的查询、申请和注销，使用起来也很方便

查询是否有截图权限：$images.getScreenCaptureOptions()

请求截图权限：$images.requestScreenCapture(options)

注销截图权限：$images.stopScreenCapture()

这里特别提一下，安卓11以上设备，一般可以不申请截图权限，直接使用无障碍权限可以获取到ajtojspro的image对象

安卓11+使用无障碍权限截图：$automator.takeScreenshot()

作者注：这种方式截图频繁有限制，一般是1秒一次。

查看使用统计权限

这个权限一般使用较少，但个别时候也有大作用，比如为了currentPackage()获取最近包名更准确，或者获取某一应用的运行状态。

由于官方没有提供此权限的查询办法，这里我查阅安卓文档，自行封装了一份，可以判断是否有此权限

checkSystemService("usage_stats")
function checkSystemService(service) {
    importClass(android.app.AppOpsManager);
    appOps = context.getSystemService(context.APP_OPS_SERVICE);
    mode = appOps.checkOpNoThrow("android:get_" + service, android.os.Process.myUid(), context.getPackageName());
    return (granted = mode == AppOpsManager.MODE_ALLOWED);
}

跳转直接使用intent即可

app.startActivity({
    action: "android.settings.USAGE_ACCESS_SETTINGS",
});

后台弹出权限（miui系统）

这个权限主要是会影响到app.launchPackage(packageName)打开未启动的应用，因此必要时我们可以判断是否有该权限，然后对用户进行提示，此权限由于是miui系统自己创造的，且没有文档说明，研究起来用了不少时间，这里我直接贴出来源码

checkMiuiPermission(10021);
function checkMiuiPermission(flag) {
    //flag为10021是后台弹出界面,为10016是NFC权限
    importClass(android.app.AppOpsManager);
    let appOps = context.getSystemService(context.APP_OPS_SERVICE);
    try {
        let myClass = util.java.array("java.lang.Class", 3);
        myClass[0] = java.lang.Integer.TYPE;
        myClass[1] = java.lang.Integer.TYPE;
        myClass[2] = java.lang.Class.forName("java.lang.String");
        let method = appOps.getClass().getMethod("checkOpNoThrow", myClass);
        let op = new java.lang.Integer(flag);
        result = method.invoke(appOps, op, new java.lang.Integer(android.os.Process.myUid()), context.getPackageName());
        return result == AppOpsManager.MODE_ALLOWED;
    } catch (err) {
        console.error(err);
    }
}

• 智能扫描设备、连接设备，永久授权后可自动连接
  
• 可在 VSCode 直接浏览、管理、编辑、运行手机设备上的文件
  
• 高效、增量、极速的文件同步，再也不用担心运行时文件缺失问题
  
• 可在 VSCode 运行和手机环境一致的远程终端，无需 adb 命令
  

除此之外，插件还有很多优化和功能完善，因此新插件的使用方式也有所不同，使用前务必阅读本教程和视频教程。

视频已失效！！！

环境准备

Auto.js Pro 9.3 以上版本

新插件需要 Pro 9.3 以上版本才能发挥全部作用，目前 9.3 版本已发布，请在官网下载。

VSCode

VSCode 是电脑上的代码编辑器，支持 Windows、Mac、Linux 等，官方下载地址：

https://wwwq.lanzouu.com/iqpJk3aaejeb

（VSCode 本身是免费的，用百度等搜索到的可能是国内无良商家的“付费”版本，请仔细辨别）

下载后，先解压压缩包，然后打开Vscode，选择扩展，右上角 => ... => 选择 从 VSIX 安装... => 选中刚刚解压的 VSIX 文件，即可成功安装上插件

安装插件

安装并打开 VSCode 后，在侧边菜单中打开拓展面板：

搜索 chinese，安装中文语言包：

搜索 hyb1996，安装 Auto.js-Pro-Ext，也即 Auto.js Pro 插件。安装后重新启动 VSCode。

连接设备

智能连接（推荐）

本连接方式的前提条件是手机和电脑在同一局域网中，比如连接到同一 WiFi，或者手机开启热点给电脑连接等。模拟器需要开启桥接模式。

打开并登录 Auto.js Pro，进入 Auto.js Pro 主界面，打开侧拉菜单，展开开发者调试，开启“允许远程调试”。

启动 VSCode，使用快捷键F1，或快捷键Ctrl + Shift + P，或在上方菜单点击查看 -> 命令面板。

在命令面板中，输入 Auto.js Pro，选择重新扫描设备。

此时手机上会弹出一个授权弹窗，选择“永久允许”或“本次允许”。

授权后会在 VSCode 右下角提示“新设备已连接”，同时在左下角显示当前设备的名称。

首次建立连接后，后续打开 VSCode 和 Auto.js Pro 后，只要重新扫描设备，即可自动连接设备，无需输入 IP 地址。

若未能连接，参考文章末尾的常见问题。

手动连接

在模拟器或其他场景时，有时我们需要手动输入 IP 地址连接设备。此连接方式也同样需要手机和电脑在同一局域网中，或者电脑有公网 IP 地址、绑定域名。

启动 VSCode，使用快捷键F1，或快捷键Ctrl + Shift + P，或在上方菜单点击查看 -> 命令面板。

在命令面板中，输入 Auto.js Pro，选择”连接到新设备“，此时可以看到电脑的 IP 地址，记住这个 IP 地址，关闭窗口。（也可以用ipconfig或ifconfig命令的高级方式查看电脑的 IP 地址）

打开 Auto.js Pro 的侧拉菜单，展开开发者调试，开启“允许远程调试”，点击”主动连接电脑“。在弹出的弹窗中输入上面的电脑 IP 地址，点击确定。

连接成功后 VSCode 将弹出“新设备已连接”，同时在左下角显示当前设备的名称。

若连接一段时间（可能很快，也可能长达一分钟）后提示错误，比如Connection Timeout，Connection Refused等，则为 IP 无法连接，有多种原因，参考文章末尾的常见问题。

USB/adb 方式连接

USB/adb 方式连接适用于电脑和手机不在同一局域网、模拟器的情况，相比起无线方式连接，此种方式的传输效率可能更高。

打开并登录 Auto.js Pro，进入 Auto.js Pro 主界面，打开侧拉菜单，展开开发者调试，开启“允许远程调试”。

使用 USB 接口将手机连接到电脑（若是模拟器，则开启模拟器的 ADB 调试、开发者调试开关），在手机的系统设置中开启开发者模式和 USB 调试。可参考网络资料或百度经验安卓手机 USB 调试模式打开的方法。

启动 VSCode，使用快捷键F1，或快捷键Ctrl + Shift + P，或在上方菜单点击查看 -> 命令面板。

在命令面板中，输入 Auto.js Pro，选择”连接到新设备“，点击使用 adb 连接。

此时会弹出所有使用 adb 连接的设备列表，选择相应设备即可自动连接到该设备。连接成功后 VSCode 将弹出“新设备已连接”，同时在左下角显示当前设备的名称。

如果此时提示”没有已通过 adb 连接到设备“，检查手机是否弹出“是否允许 USB 调试”的弹框，允许后可以再重试尝试”连接到新设备“->”使用 adb 连接设备”。

创建项目与运行代码

在 VSCode 调试中，我们建议以项目为单位进行，即使是调试一个单文件，也建议放在一个项目中，这样可获得更好的调试、自动补全体验。

打开 VSCode 的命令面板，输入”新建”，此时有两个关于 Auto.js Pro 的命令：

• 新建第一代 API 项目(Rhino)
• 新建第二代 API 项目(Node.js)

有关这两个引擎和 API 的区别请参考Auto.js Pro 文档，根据自己的需要选择项目类型。

之后会打开文件选择器，选择一个空文件夹或者新建一个新文件夹后，点击“新建到这里”即可创建项目并自动打开该项目。

默认会创建 project.json、自动补全文件、main.js 等文件，可自行新建文件、编辑代码，编辑代码也会有相应的补全和说明：

要运行代码，则打开命令面板，选择”Auto.js Pro: 运行”命令即可。或者按快捷键F5运行。快捷键可能因为冲突而无效，可以点击命令右边的设置图标重新绑定快捷键。

每次代码运行，插件会扫描电脑上的文件变化，将文件夹下的文件修改同步到设备脚本文件夹下的.remote文件夹，然后再运行文件。此过程一般很快，除非有大量（几千上万个）文件。我们建议仅打开需要编辑的项目文件夹，而不是打开比如 D 盘、包含所有项目的总文件夹。

打开已有项目或文件

这 VSCode 上方菜单中选择文件 -> 打开文件夹，选择之前已有的项目或文件即可。此时我们可以编辑和运行之前已有的项目或文件。

• 请勿打开一个很大的文件夹，比如打开整个 D 盘，或者用几千上万个脚本文件的文件夹。因为每次运行会将文件夹同步到手机上，我们只需要打开当前需要的项目或文件夹即可。过大的文件夹会导致文件同步失败或同步缓慢。
• 若运行的代码依赖其他模块文件、图片资源等，请不要仅仅打开这个文件，而是打开它所在的文件夹。当你用 VSCode 仅打开一个单文件时，运行时只有这个文件会被同步到手机上，因此打开这个文件所在的文件夹会更加合适。推荐使用项目来管理多个文件、模块和图片资源。
• 打开一个项目时，运行默认是允许当前打开的文件，若要运行项目的主文件，请选择”运行项目“命令。
• 即使打开一个项目或文件夹，”运行单文件“命令则只会同步该文件到手机，该文件夹或项目的其他文件不会被同步到手机上。

查看日志、停止运行

点击 VSCode 上面菜单，点击”查看”->”输出”打开输出面板，切换到设备的日志输出，即可查看设备的运行日志。

要停止上一次启动的脚本，在命令面板中选择”Auto.js Pro: 停止当前脚本”即可；也可选择”Auto.js Pro: 停止所有脚本”。

单步调试

单步调试是诊断 Bug、解决 Bug 的利器，它允许你一步一步地运行代码，查看代码运行的中间状态，检查变量、函数执行是否符合预期，从而发现问题，解决问题。

切换到需要单步调试的文件，在 VSCode 菜单中点击”运行” -> “启动调试”，选择”Auto.js Pro Debug”调试器，即可启动单步调试。启动后代码将在第一行停下，等待开发者操作。

右上角的调试工具栏上的几个图标分别代表：

• ▶️：继续运行
• →：单步运行，即运行当前函数的下一行代码
• ↓：单步进入，即进入到当前行的子函数里面执行
• ↑：单步跳出，执行完当前函数的剩余部分，返回到函数调用处
• 🔁：重新运行，停止当前脚本，重新重头开始运行和调试

我们还可以点击文件的某一行的左侧，给这一行下断点，当代码执行到这里时，将会在断点处停下。

在代码暂停时，左侧的变量区可以看到当前全局变量和局部变量的值；调用堆栈区可以看到当前的调用堆栈。将鼠标移动到某个变量上可以查看该变量的值

在代码暂停时，我们还可以在 VSCode 菜单”查看” -> “调试控制台”中动态执行一些表达式并获得结果：

需要注意，单步调试 UI 脚本时，可能提示“Auto.js Pro 无响应”，这是因为 UI 线程被调试所阻塞，此时点击继续等待即可。部分设备即使点了“继续等待”也会将程序杀死，在原生 Android 开发中也会遇到相同的问题。

切换设备

VSCode 支持同时连接多个设备，要切换不同设备运行代码、浏览设备文件、调试等，请点击 VSCode 左下角的设备名称：

选择设备后，再次运行则在选中的设备上运行。

浏览、管理设备文件

在 VSCode 中可直接浏览、管理、编辑、运行手机上的文件。打开 VSCode 的命令面板，输入”浏览设备文件”，选择”Auto.js Pro: 浏览设备文件”。

此时弹出选择文件夹的窗口，选择某个文件夹或者整个脚本文件夹后，点击“√”图标。

此时插件会触发重新加载（VSCode 的设计），在提示”新设备已连接“后，我们在左侧的文件管理中找到手机的文件夹，展开。

在这里我们可以新建文件、新建项目、删除文件、重命名等管理设备上的文件，也可以将电脑上的文件、文件夹通过拖拽方式传输到手机，或者右键点击手机的文件下载到电脑。

另外，可以直接编辑、运行、单步调试设备上的文件，省去文件同步、保存的时间。但由于 ts 语言服务对虚拟文件系统的限制，直接编辑设备上的文件将没有自动补全 Auto.js 函数的功能。

远程终端

在 VSCode 菜单选择”查看”->”终端”打开终端界面，点击右上角”+”旁边的下拉箭头，选择”Auto.js Pro 远程终端”。

此终端运行于手机上，环境和 Auto.js Pro 中的环境一致，可执行 node/npm 命令。

文件同步设置

默认情况下，在 VSCode 打开文件夹后，运行、调试代码会将该文件夹所有文件同步到设备脚本文件夹下的.remote临时文件夹中，保存项目、保存文件则会同步到设备的脚本文件夹下。

同步是增量、高效的，但某些文件夹可能在运行、保存时并不需要同步到手机，比如.git、build 目录，我们可以找.autojs.sync.ignore文件中配置同步忽略的文件。

文件的编写规则和.gitnore 是一致的，比如/.git规则可以忽略.git 文件下的所有文件。

常见问题

无法连接设备

可能是以下原因：

1. 手机和电脑不在同一个局域网中。查看手机的 WLAN 连接网络详情可以看到手机的 IP 地址，比如 192.168.0.10，在电脑上尝试 ping 该 IP 看能否 ping 通。
2. Windows 电脑连接后设置了公用网络。在 WLAN 设置中切换该网络为专用网络。
3. 端口被防火墙屏蔽，暂时关闭防火墙可测试是否是防火墙导致。或者在防火墙规则中添加 8129, 9317, 21029 端口的放通规则。
4. 路由器、校园网、公司网络等网络设置不允许设备互连。

VSCode 代码编辑没有 Auto.js 函数自动补全

插件的补全依赖于.d.ts 文件，默认在新建项目会附带。因此要获得自动补全，使用插件新建一个项目即可。

如果你是自行创建的文件夹或者单文件，可以新建项目后将 node_modules 文件夹、tsconfig.json 文件复制到你的文件夹中。

如果你会使用 npm 和配置 tsconfig.json，则使用 npm 安装对应的 types 文件：

• 第一代 API(rhino): @autojs/types-pro8
• 第二代 API(nodejs): @autojs/types-pro9

并在 tsconfig.json 的 typeRoots 字段增加"./node_modules/@autojs"的配置。

调试、运行时提示”open ‘extension-output-hyb1996.auto-js-pro-ext-#1-“错误

调试、运行时若出现以下提示，是因为当前焦点在日志区域或者其他区域导致。重新点击一下要运行的文件的内容，使焦点重新回到文件编辑器，再重新运行、启动调试即可。

锁屏、后台时连接断开或运行无反应

在锁屏、后台情况下，Auto.js Pro 的网络连接可能被暂停或断开，导致 VSCode 无法和手机正常通信。请开启 Auto.js Pro 的前台服务，锁定 Auto.js Pro 后台，关闭电量优化，加入后台白名单；或者保持 Auto.js Pro 始终在前台，并打开”调试时屏幕常亮“的开关。

锁屏、后台时文件管理失效

在锁屏、后台情况下，Auto.js Pro 可能无法访问文件，导致 VSCode 打开的手机文件夹显示加载中或操作失败。请开启 Auto.js Pro 的前台服务，锁定 Auto.js Pro 后台，关闭电量优化，加入后台白名单；或者保持 Auto.js Pro 始终在前台，并打开”调试时屏幕常亮“的开关。

简介

在 Android 平台上，广播接收器是一种组件，用于监听和响应系统或应用程序发出的广播消息。通过注册广播接收器，您可以在特定事件发生时执行相应的操作。

本教程将引导您使用 Auto.js Pro 和 JavaScript 编程语言编写一个简单的 Android 广播接收器，用于监听电话状态和拨打电话事件。

前提条件

在开始之前，请确保您已满足以下前提条件：

1. 安装 Auto.js Pro：您可以从 Auto.js Pro 官方网站 下载并安装 Auto.js Pro 应用程序。
2. 具备 JavaScript 基础知识：本教程假设您具备基本的 JavaScript 编程知识。

步骤 1：导入必要的类

首先，在代码中导入所需的类。在这个例子中，我们需要使用 TelephonyManager、Intent 和 IntentFilter 类。

importClass(android.telephony.TelephonyManager);
importClass(android.content.Intent);
importClass(android.content.IntentFilter);

步骤 2：创建 IntentFilter 并添加要监听的动作

接下来，创建一个 IntentFilter 对象，并添加要监听的动作。在这个例子中，我们将监听电话状态变化的动作 android.intent.action.PHONE_STATE。

let filter = new IntentFilter();
filter.addAction("android.intent.action.PHONE_STATE");

步骤 3：创建广播接收器

然后，我们将创建一个广播接收器。通过继承 android.content.BroadcastReceiver 类，并重写 onReceive 方法来实现广播接收器。

在 onReceive 方法中，我们可以根据接收到的 Intent 对象进行相应的逻辑处理。在这个例子中，我们打印出广播的动作和电话状态。

var myBroadcastReceiver = new JavaAdapter(android.content.BroadcastReceiver, {
  onReceive: function (context, intent) {
    let action = intent.getAction();
    if ("android.intent.action.PHONE_STATE" == action) {
      let state = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
      switch (state) {
        case "IDLE":
          console.log("挂断电话");
          break;
        case "RINGING":
          console.log("电话正在响铃");
          break;
        case "OFFHOOK":
          console.log("电话处于通话状态");
          break;
        default:
          break;
      }
    }
  },
});

步骤 4：注册广播接收器

接下来，我们将广播接收器注册到系统中，以便接收相应的广播消息。

context.registerReceiver(myBroadcastReceiver, filter); // 注册广播接收器

步骤 5：执行代码

最后，我们可以在一个循环中保持代码的执行，以便持续监听广播消息。在这个例子中，我们使用 setInterval 函数来实现每秒执行一次的功能。

setInterval(() => {
  // 保持代码执行
}, 1000);

步骤 6：取消注册广播接收器

在代码执行结束时，我们需要取消注册广播接收器，以释放资源，否则会导致内存泄漏。

$events.on("exit", () => {
  context.unregisterReceiver(myBroadcastReceiver);
});

完整代码

/**
 * 注册电话状态广播接收器
 */
function registerPhoneStateReceiver() {
  importClass(android.telephony.TelephonyManager);
  importClass(android.content.Intent);
  importClass(android.content.IntentFilter);

  let filter = new IntentFilter();
  filter.addAction("android.intent.action.PHONE_STATE"); // 监听电话状态变化

  let myBroadcastReceiver = new JavaAdapter(android.content.BroadcastReceiver, {
    /**
     * 接收广播回调函数
     * @param {android.content.Context} context 广播上下文对象
     * @param {Object} intent 广播意图对象
     */
    onReceive: function (context, intent) {
      let action = intent.getAction();
      if ("android.intent.action.PHONE_STATE" == action) {
        // 监听来电状态
        let state = intent.getStringExtra(TelephonyManager.EXTRA_STATE);
        switch (state) {
          case "IDLE":
            // 挂断电话
            console.log("挂断电话");
            break;
          case "RINGING":
            // 电话正在响铃
            console.log("电话正在响铃");
            break;
          case "OFFHOOK":
            // 电话处于通话状态
            console.log("电话处于通话状态");
            break;
          default:
            break;
        }
      }
    },
  });
  context.registerReceiver(myBroadcastReceiver, filter); // 注册广播接收器
  $events.on("exit", () => {
    // 取消注册广播接收器，否则会导致内存泄露
    context.unregisterReceiver(myBroadcastReceiver);
  });
}

registerPhoneStateReceiver();

setInterval(() => {
  // 用于脚本保活，ui界面不需要
}, 1000);

结论

通过以上步骤，您已经成功编写了一个简单的 Android 广播接收器，用于监听电话状态。您可以根据实际需求进一步扩展和修改代码功能。

希望本教程对您有所帮助！如果您有任何问题，请随时提问。

注意：请确保遵守当地法律法规，并尊重他人的隐私和通信权利。

在Auto.js中，我们可以使用不同的方式来实现电话拨打功能。本文将介绍其中的两种方式，并提供示例代码。

跳转拨号界面

首先，我们可以通过跳转拨号界面的方式实现电话拨打功能。这种方式不需要额外的权限，用户需要手动点击拨打按钮来完成拨号操作。

以下是使用Auto.js实现跳转拨号界面的示例代码：

var Intent = {
    action: "DIAL",
    data: "tel:10000"
};

app.startActivity(Intent);

在这段代码中，我们创建了一个名为Intent的对象，并设置了两个属性：action和data。其中，action的值为DIAL，表示拨号动作；data的值为tel:10000，表示要拨打的电话号码是10000。通过调用app.startActivity(Intent)方法，我们可以在Auto.js应用中启动系统的电话拨号界面，并自动填充电话号码为10000。

直接拨号

另一种实现电话拨打功能的方式是直接拨号。但是，这种方式需要在应用中添加相应的权限声明。

以下是使用Auto.js实现直接拨号的示例代码：

var Intent = {
    action: "android.intent.action.CALL",
    data: "tel:10000"
};

app.startActivity(Intent);

与跳转拨号界面不同，这段代码中的Intent对象设置了两个属性：action和data。其中，action的值为android.intent.action.CALL，表示进行呼叫操作；data的值为tel:10000，表示要拨打的电话号码是10000。

在中使用直接拨号方式时：

• 安卓
  • 需要在AndroidManifest.xml文件中添加相应的权限声明：

<uses-permission android:name="android.permission.CALL_PHONE" />

• Autojs
  • 需要在project.json文件中添加相应的权限声明：

{
	"permissionConfig": {
		"manifestPermissions": [
			"android.permission.CALL_PHONE"
		]
	}
}

- 建议配置启动时自动申请权限:

{
	"permissionConfig": {
		"manifestPermissions": [
			"android.permission.CALL_PHONE"
		],
		"requestListOnStartup": [
			"android.permission.CALL_PHONE"
		]
	}
}

这样才能确保Auto.js应用在运行时具有拨号权限。

总结

本文介绍了在Auto.js中实现电话拨打功能的两种方式。跳转拨号界面方式无需额外权限，但用户需要手动点击拨打按钮来完成拨号操作。直接拨号方式可以直接进行拨号，但需要在应用中添加相应的权限声明。根据实际需求，选择适合的方式来实现电话拨打功能。

本文将介绍如何使用Auto.js，在Android平台上使用JavaScript代码创建一个带有边框和圆角的渐变背景对象。我们将使用Auto.js提供的类库来实现这个功能。

导入类

首先，我们需要导入一些Android图形类，包括Color、GradientDrawable、Orientation、ShapeDrawable和RoundRectShape。这些类将用于创建和配置我们的渐变背景对象。

importClass(android.graphics.Color);
importClass(android.graphics.drawable.GradientDrawable);
importClass(android.graphics.drawable.GradientDrawable.Orientation);
importClass(android.graphics.drawable.ShapeDrawable)
importClass(android.graphics.drawable.shapes.RoundRectShape)
importClass(android.graphics.drawable.LayerDrawable)

创建带边框和圆角的GradientDrawable对象

下面是我们创建带边框和圆角的GradientDrawable对象的函数：

/**
 * 创建一个带有边框和圆角的 GradientDrawable 对象。
 *
 * @param {Object} [args] - 函数参数对象。
 * @param {string} [args.rgb='#eeeeee'] - 边框颜色，默认为灰色（#eeeeee）。
 * @param {number} [args.cornerRadius=10] - 圆角半径，默认为 10 像素。
 * @param {number} [args.alpha=255] - 填充颜色透明度，取值范围是 0 到 255，默认为不透明（255）。
 * @return {GradientDrawable} 返回一个创建好的 GradientDrawable 对象。
 */
function createBorderedDrawable(args) {
    args = args || {}
    args.rgb = args.rgb || '#eeeeee';
    args.cornerRadius = args.cornerRadius || 10;
    args.alpha = args.alpha || 255; // 注意：alpha 的取值范围是 0 到 255
    let gradientDrawable = new GradientDrawable(); // 创建一个 GradientDrawable 对象
    gradientDrawable.setStroke(2, colors.parseColor(args.rgb)); // 设置对象的边框宽度和颜色
    gradientDrawable.setOrientation(GradientDrawable$Orientation.LEFT_RIGHT); // 设置对象的方向为左右
    gradientDrawable.setCornerRadius(args.cornerRadius); // 设置对象的圆角半径
    gradientDrawable.setAlpha(args.alpha); // 设置对象的填充颜色透明度
    return gradientDrawable; // 返回创建的 GradientDrawable 对象
}

该函数接受一个可选的参数对象args，用于自定义渐变背景的属性。默认情况下，边框颜色为灰色，圆角半径为10像素，填充颜色透明度为不透明。函数首先根据参数对象来设置相应属性的值，然后创建一个GradientDrawable对象，并使用setStroke方法设置边框的宽度和颜色，使用setOrientation方法设置渐变方向为从左到右，使用setCornerRadius方法设置圆角半径，使用setAlpha方法设置填充颜色的透明度。最后，返回创建好的GradientDrawable对象。

使用示例

你可以根据自己的需求调用createBorderedDrawable函数并传入自定义的参数来创建渐变背景对象。以下是一个使用示例：

"ui";
importClass(android.graphics.Color);
importClass(android.graphics.drawable.GradientDrawable);
importClass(android.graphics.drawable.GradientDrawable.Orientation);

$ui.layout(
    <vertical gravity="center" padding="20">
        <text id="text1" text="示例" textSize="22" padding="5 10"/>
        <button id="button1" text="按钮" marginTop="10"/>
        <input id="input1" text="输入框" marginTop="10" padding="5 10"/>
        <checkbox id="checkbox1" text="复选框" marginTop="10" />
        <radio id="radio1" text="单选框1" marginTop="10"/>
    </vertical>
);
let borderedDrawable = createBorderedDrawable({
    rgb: '#ff0000',
    cornerRadius: 20,
    alpha: 200
});
$ui['text1'].setBackground(borderedDrawable)
$ui['button1'].setBackground(borderedDrawable)
$ui['input1'].setBackground(borderedDrawable)
$ui['checkbox1'].setBackground(borderedDrawable)
$ui['radio1'].setBackground(borderedDrawable)



/**
 * 创建一个带有边框和圆角的 GradientDrawable 对象。
 *
 * @param {Object} [args] - 函数参数对象。
 * @param {string} [args.rgb='#eeeeee'] - 边框颜色，默认为灰色（#eeeeee）。
 * @param {number} [args.cornerRadius=10] - 圆角半径，默认为 10 像素。
 * @param {number} [args.alpha=255] - 填充颜色透明度，取值范围是 0 到 255，默认为不透明（255）。
 * @return {GradientDrawable} 返回一个创建好的 GradientDrawable 对象。
 */
function createBorderedDrawable(args) {
    args = args || {}
    args.rgb = args.rgb || '#eeeeee';
    args.cornerRadius = args.cornerRadius || 10;
    args.alpha = args.alpha || 255; // 注意：alpha 的取值范围是 0 到 255
    let gradientDrawable = new GradientDrawable(); // 创建一个 GradientDrawable 对象
    gradientDrawable.setStroke(2, colors.parseColor(args.rgb)); // 设置对象的边框宽度和颜色
    gradientDrawable.setOrientation(GradientDrawable$Orientation.LEFT_RIGHT); // 设置对象的方向为左右
    gradientDrawable.setCornerRadius(args.cornerRadius); // 设置对象的圆角半径
    gradientDrawable.setAlpha(args.alpha); // 设置对象的填充颜色透明度
    return gradientDrawable; // 返回创建的 GradientDrawable 对象
}

上述示例中，我们调用createBorderedDrawable函数，并传入了自定义的参数对象。我们设置了边框颜色为红色、圆角半径为20像素、填充颜色透明度为200。然后，将创建的borderedDrawable对象设置为某个View的背景。

使用以上方法，你可以根据需要创建出符合你期望效果的带有边框和圆角的渐变背景对象。希望本文对你有所帮助！

"ui";
let myapp = {}
myapp.count = '9999'
myapp.time = '10'
myapp.存储标识 = "dy_cf_Y443"
let 屏幕高度 = device.height
let 屏幕宽度 = device.width
let 悬浮创建 = 0

//IMG图片数据
img_zfb = "https://s3.bmp.ovh/imgs/2022/12/31/3dfdc9646eaa3ab0.jpeg";
img_wx = "https://s3.bmp.ovh/imgs/2022/12/31/865ed7216ef93cc7.jpeg";

ui.statusBarColor("#50000000");
const AllColor = "#000000"
const alpha = 1
const primary = '#66B3FF'
ui.statusBarColor(colors.parseColor(primary));
const resourceId = context.getResources().getIdentifier("status_bar_height", "dimen", "android");
const statusBarHeight = context.getResources().getDimensionPixelSize(resourceId);
const toolbarHeight = parseInt(statusBarHeight / 2)
//自定义控件 付款方式
var v_pay_radio = [];//支付方式 单选框值
//自定义控件 付款方式
var payLayout = (function () {
    util.extend(payLayout, ui.Widget);
    function payLayout() {
        ui.Widget.call(this);
        this.defineAttr("name", (view, attr, value, defineSetter) => {
            view._pay_name.setText(value);

        });
        this.defineAttr("label", (view, attr, value, defineSetter) => {
            view._label_text.setText(value)
            switch (value) {
                case "推荐":
                    view._label_bg.attr("cardBackgroundColor", "#f5a623")
                    view._radio.attr("checked", true)
                    break;
                case "维护":
                    view._label_bg.attr("cardBackgroundColor", "#999999")
                    break;
            }
            view._label_bg.attr("visibility", "visible");
        })
        this.defineAttr("subtitle", (view, attr, value, defineSetter) => {
            view._subtitle.setText(value);
            view._subtitle.attr("visibility", "visible");

        });
        this.defineAttr("src", (view, attr, value, defineSetter) => {
            view._img.attr("src", value);
        });
        this.defineAttr("onClick", (view, name, defaultGetter) => {
            return this._onClick;
        }, (view, name, value, defaultSetter) => {
            v_pay_radio[v_pay_radio.length] = view._radio

            this._onClick = value;
        });
    }
    payLayout.prototype.render = function () {
        return (
            <vertical >
                <frame h="1" w="*" bg="#e3e3e3" />
                <horizontal marginTop="10" marginBottom="10" w="*" h="44" >
                    <img id="_img" w="44" src="#ffffff" />
                    <vertical h="*" w="auto" marginLeft="10">
                        <horizontal h="22" w="auto">
                            <text id="_pay_name" w="auto" text="未知" textSize="18" textStyle="bold" textColor="#000000" minWidth="60" />
                            <card id="_label_bg" w="auto" h="auto" marginLeft="10" layout_gravity="center_vertical" cardCornerRadius="6" cardBackgroundColor="#f5a623"
                                foreground="?selectableItemBackground" visibility="invisible">
                                <text id="_label_text" margin="10 0 10 0" text="暂无" textStyle="bold" textSize="14" textColor="#ffffff" />
                            </card>
                        </horizontal>
                        <text id="_subtitle" w="auto" h="*" gravity="bottom" text="暂无" textSize="12" visibility="invisible" />
                    </vertical>
                    <vertical w="*" h="*" gravity="right|center">
                        <radio id="_radio" w="auto" clickable="false" />
                    </vertical>
                </horizontal>
            </vertical>
        )
    };
    payLayout.prototype.onViewCreated = function (view) {
        view.on("click", () => {
            if (this._onClick) {
                for (let i = 0; i != v_pay_radio.length; i++) {
                    v_pay_radio[i].attr("checked", false);
                }
                if (view._label_text.text() == "维护") {
                    pay = 0
                    alert(view._pay_name.text() + "正在维护中")
                    view._radio.attr("checked", true)

                } else {
                    pay = view._pay_name.text()
                    view._radio.attr("checked", true)
                }
                // view._radio.attr("checked", true)
                eval(this._onClick);
            }
        });
    };
    ui.registerWidget("pay-layout", payLayout);
    return payLayout;
})();

ui.layout(
    <drawer bg="#ffffff">
        <vertical>
            <toolbar bg='{{primary}}' id="toolbar" title='承接脚本定制QQ：68107808' >
            </toolbar>
            <card margin="3 1" contentPadding="5" cardElevation="0" cardCornerRadius="10" cardBackgroundColor="#AFEEEE" alpha="{{alpha}}" >
                <TextView id="tv_text" singleLine="true" ellipsize="marquee" textSize="12" focusable="true"
                    text="本作品仅供学习交流，不得用于任何商业以及非法用途，下载试用后请24小时之内自行删除，因使用软件造成的使用者以及任何网站的一切损失， 皆由使用者承担。如不接受本条款，请立即删除本软件，如不慎软件被破解，皆由破解者承担一切责任本作品仅供学习交流!请于24小时内自行删除!"
                    textColor="#000000" />
            </card>
            <card margin="3 1" cardElevation="0" cardCornerRadius="10" cardBackgroundColor="#AFEEEE" alpha="{{alpha}}" >
                <linear gravity="left">
                    <Switch id="autoService" Thumbcolor="#000000" Trackcolor="#000000" text="无障碍服务" textColor="#000000" w="150" checked="{{auto.service != null}}" padding="8 8 8 8" textSize="15sp" />
                </linear>
                <linear gravity="right" >
                    <Switch id="overlayService" Thumbcolor="#000000" Trackcolor="#000000" text="悬浮窗权限" textColor="#000000" w="150" checked="{{auto.service != null}}" padding="8 8 8 8" textSize="15sp" />
                </linear>
            </card>
            <card margin="3 3" cardElevation="0" cardCornerRadius="10" cardBackgroundColor="#AFEEEE" alpha="{{alpha}}" >
                <vertical padding="10" h="auto">
                    <text gravity='left' text="软件说明" textColor="#009688" textSize="13sp" maxLines="1" />
                    <text gravity='left' text="1. 五云科技-老猫QQ68107808, 承接脚本定制" textColor="#222222" textSize="13sp" maxLines="1" />
                    <text gravity='left' text="2. 本软件基于Auto.js编写手写,仅用于交流学习" textColor="#222222" textSize="13sp" maxLines="1" />
                </vertical>
            </card>

            <viewpager id="viewpager">
                <frame >
                    <ScrollView  >
                        <vertical >
                            <card margin="3 1" cardElevation="0" cardCornerRadius="10" cardBackgroundColor="#AFEEEE" alpha="{{alpha}}" >
                                <vertical padding="3 1 1 1" h="auto">
                                    <linear gravity="left">
                                        <vertical w="*" h="auto" marginTop="10" bg="#AFEEEE">
                                            <vertical margin="10 10 20 10">
                                                <text text="运行模式" marginBottom="10" textSize="22" textStyle="bold" textColor="#000000" />
                                                {/* <View margin='0 1 0 1' bg='#ffffff' w='*' h='1' /> */}
                                                <pay-layout w="*" h="auto"
                                                    name="超级福袋"
                                                    src="{{img_zfb}}"
                                                    label="推荐"
                                                    subtitle="数人都在用 , 安全可托付"
                                                    onClick="pay_bnt_color1()"
                                                />
                                                <pay-layout w="*" h="auto"
                                                    name="普通福袋"
                                                    src="{{img_wx}}"
                                                    label="正常"
                                                    subtitle="诚信1 + 1 , 运行稳定可靠"
                                                    onClick="pay_bnt_color2()"
                                                />
                                                {/* <View margin='0 1 0 1' bg='#ffffff' w='*' h='1' /> */}
                                            </vertical>

                                        </vertical>
                                    </linear>
                                    <View margin='0 1 0 1' bg='#ffffff' w='*' h='1' />
                                    <linear margin="10 10 20 10"  >

                                        <text textSize="16sp" textColor="#000000" text="总参与领取福袋" w="auto" />
                                        <input gravity="center" textSize="16sp" textColor="#009688" id="count" inputType="text" text="" w="60" />
                                        <text textSize="16sp" textColor="#000000" text="次后停止运行" w="auto" />

                                    </linear>
                                </vertical>
                            </card>
                            <card margin="3 30" cardElevation="0" cardCornerRadius="10" cardBackgroundColor="#AFEEEE" alpha="{{alpha}}" >
                                <button alpha="1" bg="#AFEEEE" textColor="#000000" id="start">开启悬浮窗</button>
                            </card>
                        </vertical>
                    </ScrollView>
                </frame>

            </viewpager>
        </vertical>
    </drawer>
);

// ==================
run_type = "超级福袋"
function pay_bnt_color1() {
    run_type = "超级福袋"
    ui.run(function () {

    })
}
function pay_bnt_color2() {
    run_type = "普通福袋"
    ui.run(function () {

    })
}

ui.tv_text.setSelected(true);//设置文字滚动状态
读取界面配置(true)
//右上角设置
activity.setSupportActionBar(ui.toolbar);
//创建选项菜单(右上角)
ui.emitter.on("create_options_menu", menu => {
    menu.add("日志");
});
//监听选项菜单点击
ui.emitter.on("options_item_selected", (e, item) => {
    switch (item.getTitle()) {
        case "日志":
            app.startActivity("console");
            break;
    }
    e.consumed = true;
});

ui.autoService.on("check", function (checked) {
    // 用户勾选无障碍服务的选项时，跳转到页面让用户去开启
    if (checked && auto.service == null) {
        app.startActivity({
            action: "android.settings.ACCESSIBILITY_SETTINGS"
        });
    }
    if (!checked && auto.service != null) {
        auto.service.disableSelf();
    }
});

ui.emitter.on("resume", function () {
    // 此时根据无障碍服务的开启情况，同步开关的状态
    ui.autoService.checked = auto.service != null;
});
ui.overlayService.on("check", function (checked) {
    // 用户勾选无障碍服务的选项时，跳转到页面让用户去开启
    if (checked) {
        try {
            int = app.startActivity({
                packageName: "com.android.settings",
                className: "com.android.settings.Settings$AppDrawOverlaySettingsActivity",
                data: "package:" + context.getPackageName().toString()
            });
        } catch (err) {
            app.openAppSetting(getPackageName("dy_cf"));
        }
        toast("请打开悬浮窗开关");
    }

    if (!checked && auto.service != null) {
        // auto.service.disableSelf();
        toast("已关闭悬浮窗权限");
    }
});
ui.start.on("click", () => {   //按钮单击事件 哪个按钮 start 需要修改这个ID
    保存界面配置()          //先读取配置
    读取界面配置(false)
    if (auto.service == null) {
        toastLog("请先开启无障碍服务！");
        return
    };
    if (悬浮创建 == 0) {
        events.removeAllKeyDownListeners("volume_up")
        // 屏蔽音量键调节声音
        events.setKeyInterceptionEnabled("volume_up", true);
        events.observeKey();
        //监听音量键按下
        events.onKeyDown("volume_up", () => {
            exit()
        });

        threads.start(function () {
            日志显示(0, 屏幕高度 * 0.7, true)
        })
        悬浮创建 = 1
    }
    // home()
    toast('脚本转入后台')
    // app.launchApp("抖音")
});

function Main() {
    let number = 0
    // 记时开始
    let timeStart = timeStamp();
    dlog("当前版本：" + getVerName(app.getPackageName('抖音')) + '    执行分钟:  ' + 0 + '  /  ' + myapp.time + '    参与次数:  ' + 0 + '  /  ' + myapp.count);
    jlog('执行功能:抖音福袋')
    //判断主页
    while (true) {
        if (!desc("更多面板 按钮").visibleToUser().exists()) {
            jlog('请在直播间运行')
        } else { break }
        sleep(1500)
    }

    while (true) {
        jlog("抖音直播间已打开")
        sleep(3000)
        if (!descContains('超级福袋').visibleToUser().exists()) {
            swipe_downUp(true)
            sleep(3000)
            jlog("未发现超级福袋")
        } else {
            jlog("超级福袋......")
            sleep(1000)
            break
        }
    }
    // =========================

    while (true) {
        if (desc('活动已结束').visibleToUser().exists()) { back(); clog('活动结束，返回'); }
        sleep(300)
        if (descContains('参与成功').visibleToUser().exists()) { back(); jlog('参与成功，等待开奖'); }
        sleep(300)
        if (descContains('我知道了').visibleToUser().exists()) { back(); clog('我知道了，返回'); }
        sleep(300)
        if (desc('一键发表评论').visibleToUser().exists()) {
            clickCoords('desc', '一键发表评论', true);
            clog('一键发表评论');
            ++number
        }

        sleep(300)
        if (descContains('超级福袋').visibleToUser().exists()) { clickCoords('desc', '超级福袋', true); jlog('点击超级福袋'); }
        var timeUp = timeStamp();
        var record = timeUp - timeStart
        dlog("当前版本：" + getVerName(app.getPackageName('抖音')) + '    执行分钟:  ' + (record / 60).toFixed(1) + '  /  ' + myapp.time + '    参与次数:  ' + number + '  /  ' + myapp.count);
        if (number >= parseInt(myapp.count)) {
            sleep(300)
            tlog('停止运行')
            console.hide()
            alert("运行完毕");
            sleep(300)
            exit()
            return
        }
    }
}

function 普通福袋() {
    let number = 0
    // 记时开始
    let timeStart = timeStamp();
    dlog("当前版本：" + getVerName(app.getPackageName('抖音')) + '    执行分钟:  ' + 0 + '  /  ' + myapp.time + '    参与次数:  ' + 0 + '  /  ' + myapp.count);
    jlog('执行功能:抖音普通福袋')
    //判断主页
    while (true) {
        if (!desc("更多面板 按钮").visibleToUser().exists()) {
            jlog('请在直播间运行')
        } else { break }
        sleep(1500)
    }

    while (true) {
        jlog("抖音直播间已打开")
        sleep(3000)
        if (!descStartsWith('福袋').visibleToUser().findOnce()) {
            swipe_downUp(true)
            sleep(3000)
            jlog("未发现普通福袋")
        } else {
            jlog("福袋......")
            sleep(1000)
            break
        }
    }
    // =========================
    while (true) {
        if (desc('活动已结束').visibleToUser().exists()) { back(); clog('活动结束，返回'); }
        sleep(300)
        if (descContains('参与成功').visibleToUser().exists()) { back(); jlog('参与成功，等待开奖'); }
        sleep(300)
        if (descContains('我知道了').visibleToUser().exists()) { back(); clog('我知道了，返回'); }
        sleep(300)
        if (textContains('已参与').visibleToUser().exists()) { back(); clog('已参与，返回'); }

        sleep(300)
        if (textContains('去发表评论').visibleToUser().exists()) {
            clickCoords('text', '去发表评论', true);
            sleep(2000)
            clickCoords("desc", '发送', true)
            clog('去发表评论');
            ++number
        }

        sleep(300)
        if (descStartsWith('福袋').visibleToUser().findOnce()) { 
            var w = descStartsWith('福袋').visibleToUser().findOnce().bounds()
            click(w.centerX(), w.centerY())
            sleep(500)
            jlog('点击福袋'); 
        }
        var timeUp = timeStamp();
        var record = timeUp - timeStart

        dlog("当前版本：" + getVerName(app.getPackageName('抖音')) + '    执行分钟:  ' + (record / 60).toFixed(1) + '  /  ' + myapp.time + '    参与次数:  ' + number + '  /  ' + myapp.count);

        if (number >= parseInt(myapp.count)) {
            sleep(300)
            tlog('停止运行')
            console.hide()
            alert("运行完毕");
            sleep(300)
            exit()
            return
        }
    }
}


//下滑
function swipe_downUp(Vertical) {
    let x = device.width / 2
    let y1 = parseInt(device.height * 0.8)
    let y2 = parseInt(device.height * 0.1)
    if (Vertical) {
        gesture(random(500, 800), [x + random(-30, 30), y1], [x + random(-30, 30), y1 - 200], [x + random(-20, 20), y1 - 400], [x + random(-20, 20), y2])
    } else {
        gesture(random(500, 800), [x + random(-30, 30), y2 + 100], [x + random(-30, 30), y2 + 300], [x + random(-20, 20), y2 + 500], [x + random(-20, 20), y1])
    }

}

function timeStamp() {
    return Date.parse(new Date()) / 1000;
}

//随机秒数
function getRandom(min, max) {
    // console.log("停留：" + random(parseInt(min), parseInt(max)) + " 毫秒");
    return random(parseInt(min), parseInt(max))

}
function clickCoords(type, value, isContain) {
    if (isContain) {
        switch (type) {
            case "id":
                try {
                    var w = idContains(value).visibleToUser().findOnce().bounds()
                    click(w.centerX(), w.centerY())
                    sleep(500)
                    return true
                } catch (e) { console.log(e); return false }
            case "text":
                try {
                    var w = textContains(value).visibleToUser().findOnce().bounds()
                    click(w.centerX(), w.centerY())
                    sleep(500)
                    return true
                } catch (e) { console.log(e); return false }
            case "desc":
                try {
                    var w = descContains(value).visibleToUser().findOnce().bounds()
                    click(w.centerX(), w.centerY())
                    sleep(500)
                    return true
                } catch (e) { console.log(e); return false }
            default:
                return false
        }
    } else {
        switch (type) {
            case "id":
                try {
                    var w = id(value).visibleToUser().findOnce().bounds()
                    click(w.centerX(), w.centerY())
                    sleep(500)
                    return true
                } catch (e) { console.log(e); return false }
            case "text":
                try {
                    var w = text(value).visibleToUser().findOnce().bounds()
                    click(w.centerX(), w.centerY())
                    sleep(500)
                    return true
                } catch (e) { console.log(e); return false }
            case "desc":
                try {
                    var w = desc(value).visibleToUser().findOnce().bounds()
                    click(w.centerX(), w.centerY())
                    sleep(500)
                    return true
                } catch (e) { console.log(e); return false }
            default:
                return false
        }
    }

}

//软件版本
function getVerName(package_name) {
    let pkgs = context.getPackageManager().getInstalledPackages(0).toArray();
    for (let i in pkgs) {
        if (pkgs[i].packageName.toString() === package_name) return pkgs[i].versionName;
    }
}

//===============
function 日志显示(x, y, is) {
    if (typeof x != 'number') x = 0;
    if (typeof y != 'number') y = 10;
    let floatyLogW = floaty.rawWindow(
        <card id="main" marginLeft="3" h="150" cardBackgroundColor='#b3000000' cardCornerRadius="8dp" cardElevation="1dp" gravity="center_vertical">
            <vertical padding="5 5 5 0" w='*'>
                <button layout_gravity="center" id='顶层显示' textSize="11dp" textColor="#20B2AA" style="Widget/AppCompat.Button.Borderless" textStyle='bold'
                    layout_width="wrap_content" layout_height="15dp" />
                <button gravity="center_horizontal" textColor="#DC143C" w="*" h="13" textStyle='bold' marginBottom="3" />
                <vertical padding="5 0">
                    <button id='log1' textSize="12dp" textColor="#FFF5EE" style="Widget/AppCompat.Button.Borderless" textStyle='normal'
                        layout_gravity="left" layout_width="wrap_content" layout_height="15dp" />

                    <button id='log2' textSize="12dp" textColor="#FFF5EE" style="Widget/AppCompat.Button.Borderless" textStyle='normal'
                        layout_gravity="left" layout_width="wrap_content" layout_height="15dp" />

                    <button id='log3' textSize="12dp" textColor="#FFF5EE" style="Widget/AppCompat.Button.Borderless" textStyle='normal'
                        layout_gravity="left" layout_width="wrap_content" layout_height="15dp" />

                    <button id='log4' textSize="12dp" textColor="#FFF5EE" style="Widget/AppCompat.Button.Borderless" textStyle='normal'
                        layout_gravity="left" layout_width="wrap_content" layout_height="15dp" />

                    <button id='log5' textSize="12dp" textColor="#FFF5EE" style="Widget/AppCompat.Button.Borderless" textStyle='normal'
                        layout_gravity="left" layout_width="wrap_content" layout_height="15dp" />

                    <button id='log6' textSize="12dp" textColor="#FFF5EE" style="Widget/AppCompat.Button.Borderless" textStyle='normal'
                        layout_gravity="left" layout_width="wrap_content" layout_height="15dp" />

                    <button id='log7' textSize="12dp" textColor="#FFF5EE" style="Widget/AppCompat.Button.Borderless" textStyle='normal'
                        layout_gravity="left" layout_width="wrap_content" layout_height="15dp" />
                </vertical>
            </vertical>
        </card>
    );
    控制按钮 = floaty.rawWindow(
        <vertical h="150">
            <text layout_weight="5" id="启动" textStyle="bold" gravity="center" w="22" text="启动" bg="#00a86b" />
            <text layout_weight="5" id="隐藏" textStyle="bold" gravity="center" w="22" text="日志" bg="#FF8E12" />
            <text layout_weight="5" id="结束" textStyle="bold" gravity="center" w="22" text="结束" bg="#d71345" />
        </vertical>
    );
    let arr = []
    arr[0] = floatyLogW.log1
    arr[1] = floatyLogW.log2
    arr[2] = floatyLogW.log3
    arr[3] = floatyLogW.log4
    arr[4] = floatyLogW.log5
    arr[5] = floatyLogW.log6
    arr[6] = floatyLogW.log7
    let islog = []
    let i = 0
    let thread = null
    tlog = function (msg) {
        msg = '[' + dateFormat(new Date(), "HH:mm:ss") + '] >> ' + msg
        let 余数 = msg.length % 40
        let 运算结果 = parseInt(msg.length / 40)
        if (余数 > 0) {
            运算结果++
        }
        let x = 40
        for (let ii = 0; ii < 运算结果; ii++) {
            let ks = ii * 40
            let js = x
            let obj = {}
            obj.is = msg.slice(ks, js)
            obj.color = colors.rgb(255, 255, 255)
            islog.push(obj);
            x = x + 40
        }
        ui.run(() => {
            let 数组长度 = islog.length
            if (数组长度 > 7) {
                let 裁剪长度 = 数组长度 - 7
                islog = islog.slice(裁剪长度);
                // log('数组长度：' + islog.length)
                for (let s = 0; s < islog.length; s++) {
                    arr[s].setTextColor(islog[s].color)
                    arr[s].text('  ' + islog[s].is)
                    if (is) log(islog[s].is)
                }
            } else {
                for (let s = 0; s < islog.length; s++) {
                    arr[s].setTextColor(islog[s].color)
                    arr[s].text('  ' + islog[s].is)
                    if (is) log(islog[s].is)
                }
            }
        })
    }

    jlog = function (msg) {
        msg = '[' + dateFormat(new Date(), "HH:mm:ss") + '] >> ' + msg
        let 余数 = msg.length % 40
        let 运算结果 = parseInt(msg.length / 40)
        if (余数 > 0) {
            运算结果++
        }
        let x = 40
        for (let ii = 0; ii < 运算结果; ii++) {
            let ks = ii * 40
            let js = x
            let obj = {}
            obj.is = msg.slice(ks, js)
            obj.color = colors.rgb(255, 255, 0)
            islog.push(obj);
            x = x + 40
        }
        ui.run(() => {
            let 数组长度 = islog.length
            if (数组长度 > 7) {
                let 裁剪长度 = 数组长度 - 7
                islog = islog.slice(裁剪长度);
                // log('数组长度：' + islog.length)
                for (let s = 0; s < islog.length; s++) {
                    arr[s].setTextColor(islog[s].color)
                    arr[s].text('  ' + islog[s].is)
                    if (is) log(islog[s].is)
                }
            } else {
                for (let s = 0; s < islog.length; s++) {
                    arr[s].setTextColor(islog[s].color)
                    arr[s].text('  ' + islog[s].is)
                    if (is) log(islog[s].is)
                }
            }
        })
    }

    clog = function (msg) {
        msg = '[' + dateFormat(new Date(), "HH:mm:ss") + '] >> ' + msg
        let 余数 = msg.length % 40
        let 运算结果 = parseInt(msg.length / 40)
        if (余数 > 0) {
            运算结果++
        }
        let x = 40
        for (let ii = 0; ii < 运算结果; ii++) {
            let ks = ii * 40
            let js = x
            let obj = {}
            obj.is = msg.slice(ks, js)
            obj.color = colors.rgb(255, 0, 0)
            islog.push(obj);
            x = x + 40
        }
        ui.run(() => {
            let 数组长度 = islog.length
            if (数组长度 > 7) {
                let 裁剪长度 = 数组长度 - 7
                islog = islog.slice(裁剪长度);
                // log('数组长度：' + islog.length)
                for (let s = 0; s < islog.length; s++) {
                    arr[s].setTextColor(islog[s].color)
                    arr[s].text('  ' + islog[s].is)
                    if (is) log(islog[s].is)
                }
            } else {
                for (let s = 0; s < islog.length; s++) {
                    arr[s].setTextColor(islog[s].color)
                    arr[s].text('  ' + islog[s].is)
                    if (is) log(islog[s].is)
                }
            }
        })
    }

    dlog = function (printContent) {
        ui.run(() => {
            // floatyLogW.顶层显示.setTextColor(colors.parseColor("#c37e00"))
            floatyLogW.顶层显示.text('  ' + printContent)
        })
    }

    function dateFormat(date, fmt_str) {
        return java.text.SimpleDateFormat(fmt_str).format(new Date(date || new Date()));
    }

    ui.run(() => {
        floatyLogW.setTouchable(false);
        floatyLogW.setSize(-1, -2);
        floatyLogW.setPosition(3000, 3000)
        控制按钮.setPosition(0, y);
        控制按钮.结束.click(() => {
            toast("结束脚本运行");
            exit()
        });
        控制按钮.隐藏.click(() => {
            if (控制按钮.隐藏.text() == "隐藏") {
                floatyLogW.setPosition(3000, 3000)
                控制按钮.隐藏.setText("日志")
                控制按钮.隐藏.attr("background", "#FF8E12");
            } else if (控制按钮.隐藏.text() == "日志") {
                控制按钮.隐藏.setText("隐藏")
                控制按钮.隐藏.attr("background", "#d1c7b7");
                floatyLogW.setPosition(x + 20, y);
            }
        });
        控制按钮.启动.click(() => {
            if (thread ? !thread.isAlive() : true) { //线程没有运行。
                控制按钮.启动.setText("暂停");
                控制按钮.启动.attr("background", "#05a7f4");
                //新建一个线程，赋值给变量thread
                thread = threads.start(function () {
                    try {
                        if(run_type == "超级福袋") {
                            Main();
                        } else {
                            普通福袋();
                        }
                        
                    } catch (e) { console.log("程序启动失败");console.log(e) };
                    //运行完毕修改按钮文字
                    ui.run(() => { 控制按钮.启动.setText("启动"); })

                });
            } else {
                thread.interrupt();
                //中断线程;
                控制按钮.启动.setText("启动");
                控制按钮.启动.attr("background", "#00a86b");
            };
        });
    })
};

//====================
function 保存界面配置() {
    //  执行数
    保存本地数据(myapp.存储标识, "count", ui.count.text())
};

function 读取界面配置(是否设置组件值) {   //逻辑值 是否设置组件值
    // 点赞数
    if (读取本地数据(myapp.存储标识, "count") != undefined) {
        myapp.count = 读取本地数据(myapp.存储标识, "count")
    };
    是否设置组件值 && ui.count.setText(myapp.count);
};
function 保存本地数据(存储标识, ID, 界面组件值) {
    const storage = storages.create(存储标识);  //创建storage对象
    storage.put(ID, 界面组件值);
};
function 读取本地数据(存储标识, ID) {
    const storage = storages.create(存储标识);  //创建storage对象
    if (storage.contains(ID)) {
        return storage.get(ID, "");
    };
    //默认返回undefined
};