📖 古龙精灵 API 参考手册

-- 点击坐标
tap(100, 100)

-- 配合找图使用
local result = find_image("images/button.png")
if result and result.success then
    tap(result.x, result.y)
end

longTap(100, 100)

-- 方式1：矩形范围内随机点击
tapRandom(100, 200, 300, 400)

-- 方式2：圆形半径内随机点击
tapRandom(500, 800, 50)

-- 从左滑到右
swipe(200, 200, 800, 200, 500)

-- 向上滑动翻页
swipe(540, 800, 540, 200, 300)

-- ① 经典写法：曲线、时长、微抖全部自动随机
swipeHuman(200, 200, 800, 200)

-- ② 经典写法：指定耗时 500ms + 弯曲强度 0.3（弯得更明显）
swipeHuman(540, 800, 540, 200, 500, 0.3)

-- ③ 间隔写法（对齐 xdvip.滑动_模拟真人SSF）：采样间隔 0.1px + 波动 1，并拿到路径点
local path = swipeHuman(300, 1200, 700, 600, 0.1, 1)
if path then
    log("走了 " .. path.n .. " 个点 / " .. path.duration .. "ms")
    local p = path[1]   -- {x=, y=, t=}，也可以写 p[1] / p[2]
end

-- ④ 循环滑动时配合随机等待，更像真人操作
for i = 1, 3 do
    swipeHuman(540, 800, 540, 200)
    random_sleep(300, 900)
end

-- ⑤ 在误触风险大的界面可传 curve=0（接近直线，但仍有微抖）
swipeHuman(300, 900, 300, 300, 400, 0)

-- ① 推荐：按住拖动用 touchMoveEx（无障碍 / root 都支持），一行顶替几百次 touchMove
touchDown(1, 100, 100)
sleep(50)
touchMoveEx(1, 300, 300, 800)   -- 第4个参数 = 这段滑动的耗时 800ms
touchUp(1)                     -- 无障碍：真正的滑动在这一步发出，它的返回值才是本次结果

-- ② 只在 root 通道下才需要逐步移动（每步 sleep 才有意义）
touchDown(1, 297, 327)
for i = 1, 20 do
    touchMove(1, 297, 327 - i * 15)
    sleep(16)   -- 无障碍模式下 touchMove 只是登记目标点，这些 sleep 不会产生中间触点
end
touchUp(1)

-- ③ 常规滑动更推荐 swipeHuman（自动选通道 + 拟人曲线，一行搞定）
swipeHuman(540, 800, 540, 200)

-- 从 (100,100) 按住后平滑滑到 (300,300)，耗时 800 毫秒
touchDown(1, 100, 100)
sleep(50)
touchMoveEx(1, 300, 300, 800) -- 第4个参数 time=800 就是这段滑动的耗时
touchUp(1) -- 无障碍模式下真正的滑动在 touchUp 时按 time 发出

-- 按HOME键
keyPress("home")
-- 按返回键
keyPress("back")

-- 删除键：del = 退格（删光标前一个字符）；forward_del = Delete（删光标后一个字符）
keyPress("del")
keyPress("forward_del")

-- 强制走 root 通道（游戏只认硬件删除键时）
keyPress("del", "root")
keyPress("del", {channel = "root"})

-- 账号/密码框建议直接按文本删除，不依赖硬件 DEL
imeLib.lock()
imeLib.deleteChar()
imeLib.clearText()

-- 按下并弹起（只有古龙输入法能真正只发 DOWN/UP）
keyDown("home")
sleep(100)
keyUp("home")

-- 常规输入（聊天框 / 账号 / 密码框）
tap(300, 800)  -- 先点击输入框唤起输入法
sleep(800)
inputText("hello123")

-- 中文/空格请用输入法通道
imeLib.setText("你好 world")

-- 推荐：锁定古龙输入法（不弹键盘，支持中文）
setStopCallBack(function(error)
    imeLib.unlock()
end)
imeLib.lock()
imeLib.setText("公会副本马上开始")
imeLib.finishInput()   -- 回车/发送
imeLib.unlock()        -- 手动解锁（脚本停止时也会自动解锁）

-- 账号 + 密码登录框
tap(acc_x, acc_y)
imeLib.setText("player123")
tap(pwd_x, pwd_y)
imeLib.setText("p@ss w0rd")  -- 含空格/符号也可输入

-- 删除一个字符 / 清空整个输入框
imeLib.deleteChar()
imeLib.clearText()      -- 一次清空，适合输错重输

-- 推荐：把脚本的收尾清理都写进停止回调，手动停止 / 脚本跑完 / 报错退出都会执行
setStopCallBack(function(error)
    imeLib.unlock()                                        -- 解锁古龙输入法，恢复系统输入法
    close_message_keep()                                   -- 关闭 show_message_keep 驻留消息窗
    execRoot("settings put global policy_control null")    -- 恢复状态栏显示
end)

-- 最简用法：只做一件事
setStopCallBack(function(error)
    imeLib.unlock()
end)

function onTouchEvent(x, y)
    log("触摸坐标: " .. x .. ", " .. y)
end
setOnTouchListener(onTouchEvent)
sleep(1000000)

-- 1) 截图到内存（用于找图 / 切图）
local img = screenshot()
local crop = image_crop(img, 100, 200, 300, 400)

-- 2) 截图并保存到文件（设备端与 PC 本地都支持）
screenshot("output/screen.png")

-- 3) 截图后直接找图（模板用路径方式）
if find_image("images/target.png") then
    log("找到目标")
end

-- 1) 路径方式（图片放在项目 images/ 下，会随项目下发到设备）
local result = find_image("images/button.png")
if result and result.success then
    tap(result.x, result.y)
    log(string.format("相似度: %.2f", result.confidence))
end

-- 2) __base64__ 内嵌数据（抓取窗口可直接生成，不依赖设备上有图片文件）
local TPL = "__base64__:iVBORw0KGgoAAAANSUhEUg..."
local r = find_image(TPL, 0, 0, 1080, 1920, 0.9, 10)
if r and r.success then tap(r.center_x, r.center_y) end

-- 3) 只在小区域内找 + 放宽相似度 / 偏色（找得慢就缩小区域，误匹配多就调高相似度）
local r2 = find_image("images/icon.png", 100, 200, 500, 800, 0.8, 20)

-- 4) 兼容写法：旧签名（模板, 阈值）仍然可用
local r3 = find_image("images/target.png", 0.8)

-- 等待图片出现（最多等10秒）
local result = wait_image("images/loading_done.png")
if result then
    tap(result.x, result.y)
end

-- 等 30 秒 + 限定区域 + 相似度 0.85
local r = wait_image("images/login_success.png", 30, 0.85, 0, 0, 1080, 600)
if not r then
    log("登录超时！")
end

if exists("images/button.png") then
    log("按钮存在")
    tap(100, 200)
end

-- 限定区域 + 放宽偏色（适合图标在不同机器上有色差的场景）
if exists("images/success.png", 0.85, 0, 0, 1080, 600, 20) then
    log("成功!")
end

-- 把抓取窗口生成的 __base64__ 数据存进脚本，运行时解码成图片数据
local TPL = table.concat({
    "__base64__:iVBORw0KGgoAAAANSUhEUg...",
    "...",
})
local img = base64_decode(TPL)
local r = find_image(img, 0, 0, 1080, 1920, 0.9, 10)
if r and r.success then tap(r[1], r[2]) end

-- 说明：直接把 "__base64__..." 字符串交给 find_image 也可以，效果一样

-- 获取坐标颜色并解析RGB
local color = get_color(500, 300)
local r, g, b = tonumber("0x"..color:sub(1,2)), tonumber("0x"..color:sub(3,4)), tonumber("0x"..color:sub(5,6))
log(r..","..g..","..b)

-- 判断颜色
if r > 200 then log("该点偏红") end

-- 查找所有红色像素
local points = find_color({255, 0, 0}, 20)
log("找到 " .. #points .. " 个红色像素点")

local result = findMultiColor(0, 0, 1080, 1920, "ff0000", "10|0|00ff00|20|0|0000ff", 0, 0.9)
if result then
    tap(result[1], result[2])
end

local MultiColorTargets = {
    {"845635", "-9|8|d7c189|-77|-3|7a4829"},
    {"efe3d3", "36|-18|e3c288|-10|6|efe1d3"},
}
local result = findMultiColorTargets(0, 0, 1080, 1920, MultiColorTargets, 0, 0.9)
if result then tap(result[1], result[2]) end

local MultiColorStr = {
    {"系统", "e7c548", "2|15|f2a91a|-25|-3|dac04f"},
    {"返回", "ff0000", "10|0|00ff00|20|0|0000ff"},
}
local result = findMultiColorStr(0, 0, 1080, 1920, MultiColorStr, 0, 0.9)
if result then tap(result[1], result[2]) end

local MultiColorStr = {
    {"天兵", "e7c548", "2|15|f2a91a|-25|-3|dac04f"},
    {"亢金龙", "efe3d3", "36|-18|e3c288|-10|6|efe1d3"},
}
local r = getMultiColorStr(0, 0, 1080, 1920, MultiColorStr, 0, 0.9)
if r and r.success then log("当前界面元素: " .. r.text) end

-- 比较多点颜色
local ret = cmpColorEx("ff0000", "10|0|00ff00|20|0|0000ff", 0, 0.9)
if ret ~= -1 then log("颜色匹配成功") end

-- 查找所有匹配位置
local results = findMultiColorAll(0, 0, 1080, 1920, "ff0000", "10|0|00ff00|20|0|0000ff")
for i, pos in ipairs(results) do
    tap(pos[1], pos[2])
end

local number = getColorNum(10, 50, 600, 600, "e91e1e", 0.8)
print(number)

-- 判断按钮状态：区域内红色像素多 → 按钮点亮
local redNum = getColorNum(100, 200, 300, 250, "e91e1e", 0.9)
if redNum > 200 then
    tap(200, 225)
end

-- 多颜色 + 偏色
local num = getColorNum(0, 0, 500, 300, "ff0000|00ff00-202020", 0.85)

local text = ocr_recognize_local("ch", { 987, 332, 1121, 368 })
if text.success then
    log("识别结果: " .. text.text)
    if text.text == "开始挑战" then
        tap(1050, 350)
    end
end

local pos = ocr_find_text_local("开始", nil, {987, 332, 1121, 368})
if pos and pos.found then
    -- 点击文字中心
    tap(pos.x + pos.w / 2, pos.y + pos.h / 2)
end

local detail = ocr_recognize_detail_local("ch", {800, 300, 1200, 500})
if type(detail) == "table" and detail.success then
    -- 没有 detail.count / detail.text：数量用 #detail.results，文字自己拼
    log("识别到 " .. #(detail.results or {}) .. " 个文字块")
    for i, item in ipairs(detail.results or {}) do
        if string.find(tostring(item.text or ""), "开始挑战", 1, true) then
            -- 中心点取整：小数进 %d 会报 number has no integer representation
            tap(math.floor(item.x + item.w / 2), math.floor(item.y + item.h / 2))
            break
        end
    end
else
    log("识别失败: " .. tostring(detail and detail.error or detail))
end

local result = ocr_find_text_all_local("确认", nil, {100, 200, 600, 400})
if result.found then
    -- 从下往上点击所有匹配项
    for i = result.count, 1, -1 do
        local item = result.results[i]
        tap(item.x + item.w / 2, item.y + item.h / 2)
        sleep(500)
    end
end

local result = yolo_detect()
if result.success then
    log("检测到 " .. result.count .. " 个物体")
    for i, det in ipairs(result.detections) do
        log(string.format("%s: %.2f, (%d,%d)", det.class_name, det.confidence, det.center_x, det.center_y))
    end
    -- 点击第一个检测到的物体
    if result.count > 0 then
        tap(result.detections[1].center_x, result.detections[1].center_y)
    end
end

-- 加载自定义模型
local result = yolo_load_custom_model("resources/models/yolov11_npc.param")
if result.success then
    log("类别: " .. table.concat(result.class_names, ", "))
    -- 执行检测
    local det = yolo_detect(0.35)
end

-- 从文件检测
local result = yolo_detect_file("screenshot.png")

-- 检测并绘制
local result = yolo_detect_and_draw()

-- 加载内置模型
yolo_load_model("yolo11n")  -- Nano最快
yolo_load_model("yolo11s")  -- Small

-- 查看可用模型
local models = yolo_get_available_models()
for i, m in ipairs(models) do
    log(m.name .. ": " .. (m.exists and "✅" or "⬇️"))
end

sleep(2000)   -- 等待2秒
sleep(500)    -- 等待0.5秒

random_sleep(1000, 3000)   -- 随机等待1~3秒
tap(500, 300)
random_sleep(300, 800)   -- 模拟人类点击间隔
tap(500, 400)

log("脚本开始执行")
log(string.format("坐标: (%d, %d)", x, y))

-- 全局变量
if user_settings.auto_fight then log("自动打怪已开启") end

-- 安全获取
local val = get_setting("key", defaultValue)

-- 动态修改（返回 boolean；table 等复杂值会存成 JSON 字符串）
local ok = set_setting("key", newValue)

-- 在面板按钮触发的全局函数内使用（params 由平台传入）
local boss_no = get_live_setting("boss_no", 1)
local auto_fight = get_live_setting("auto_fight", false)
local target = get_live_setting("target_monster", "银月贤者")

-- 兼容旧 APK：直接读动作参数里的快照
local live = (params and params.live_settings) or {}
local boss_no_old = live.boss_no or get_setting("boss_no", 1)

-- 1) 面板按钮声明（settings_fields.lua）
-- 【片段】第 1 步的按钮声明属于 settings_fields.lua（不能单独运行/检查）
{key = "btn_open_log", label = "查看日志", type = "button",
 func = "判断_打开文件", style = "primary", confirm = "确定查看？"}

-- 【可运行代码】下面这段可以直接运行/语法检查
-- 2) 脚本只写业务函数即可（平台会自动派发，不需要轮询）
function 判断_打开文件(params)
    show_message("已执行一键日常")
end

-- 3)【可选】自己掌控执行时机时才需要下面这段
for _, act in ipairs(poll_user_actions() or {}) do
    local f = _G[act.func]
    if type(f) == "function" then pcall(f, act.params) end
end

local resp = http_get("http://api.example.com/data")
local data = json_parse(resp)

local resp = http_post("http://api.example.com/login", nil, {username = "admin", password = "123456"})

open_url("http://www.baidu.com")

-- 以古龙精灵为例：相对路径 = App 内置 scripts 目录
local ok = write_file("result.txt", "执行完成")
log("写入结果: " .. tostring(ok))

-- 写入JSON配置
local data = {time = os.time(), status = "ok"}
write_file("data.json", json_stringify(data))

-- ===== 绝对路径示例（雷电模拟器）=====
-- /sdcard 等价于 /storage/emulated/0
local ok2 = write_file("/sdcard/Download/gulong/data.txt", "Hello World")
log(read_file("/storage/emulated/0/Download/gulong/data.txt"))

-- 雷电共享目录（Windows 对应：文档\LDPlayer\Pictures）
write_file("/mnt/shared/Pictures/gulong_test.txt", "Hello LDPlayer")

-- 相对路径（「古龙精灵」= App 内置 scripts 目录 / 「古龙代码箱」= 当前工程目录）
local del_ok = delete_file("data.txt")
-- delete_file 返回 boolean(true/false)，必须 tostring；否则 string .. boolean 会报
-- "attempt to concatenate string and boolean"。也可写成：
--   log("结果: " .. (del_ok and "删除成功" or "删除失败/文件不存在"))
log("结果: " .. tostring(del_ok))

-- 用 if 判断更直观
if delete_file("old_log.txt") then
    log("旧日志已删除")
else
    log("旧日志不存在或删除失败")
end

-- ===== 绝对路径示例（雷电模拟器）=====
-- /sdcard 等价于 /storage/emulated/0；无权限时设备已 root 会自动用 su（rm -rf）回退
local del_abs = delete_file("/sdcard/Download/gulong/data.txt")
log("删除结果: " .. tostring(del_abs))

-- 删除整个目录（含子文件，递归删除）
log("目录删除: " .. tostring(delete_file("/sdcard/Download/gulong/old_logs")))

-- 雷电共享目录（Windows 对应：文档\LDPlayer\Pictures）
delete_file("/mnt/shared/Pictures/gulong_test.txt")

local result = call_python("scripts/my_module.py", "process_data", "input.txt")

local account = get_account_info()
if account then
    log("账号: " .. account.account_id .. " @ " .. account.server_url)
else
    log("未登录 / 没有账号上下文")
end

local info = get_device_info()
log("设备: " .. info.device_name .. " (" .. info.brand .. " " .. info.model .. ")")
log("分辨率: " .. info.resolution .. " 密度: " .. info.density)
log("系统: Android " .. info.os_version .. " (SDK " .. info.sdk_int .. "), 运行环境: " .. info.platform)

-- 推荐写法：显式传 GAMENAME（开发者面板按游戏分类）
local r = server_api.report_message("开始执行：第 " .. round .. " 轮", GAMENAME)
if not r.success then
    log("回传失败: " .. tostring(r.error))
end

-- 也可以直接调用全局函数（等价写法）
report_message("任务完成，用时 " .. seconds .. " 秒")

-- 高频循环里用 nowait：后台发送，不阻塞脚本（2 秒内重复调用会被节流）
report_message_nowait("血量 " .. hp .. "/" .. hp_max, GAMENAME)

-- 阻塞版：等截图 + 上传完成，返回本次额度
local r = server_api.bug_screenshot()
if r.success then
    log("截图已发送: " .. tostring(r.filename)
        .. "，今日 " .. tostring(r.used) .. "/" .. tostring(r.limit))
else
    log("截图失败: " .. tostring(r.error))
end

-- 后台版：不阻塞脚本，返回 true=已排队（false=未登录/2 秒节流/上一张未完成）
if bug_screenshot_nowait() then
    log("截图任务已提交")
end

-- 播放内置提示音（默认音量 80、时长 400ms）
play_sound("ok")

-- 自定义音量 + 时长（约 1 秒）
play_sound("error", 100, 1000)

-- 播放本地音频文件（相对路径：古龙精灵 = App 内置 scripts 目录，古龙代码箱 = 当前工程目录）
play_sound("alert.mp3")

-- 绝对路径 / App 内置 assets 里的音频
play_sound("/sdcard/Music/bgm.mp3", 60)
play_sound("assets:alert.mp3", 80)

-- 循环播放背景音，10 秒后 stop_sound() 停止
play_sound("/sdcard/Music/bgm.mp3", 50, 0, true)
sleep(10000)
stop_sound()

-- 循环播放 10 秒后停止
play_sound("/sdcard/Music/bgm.mp3", 50, 0, true)
sleep(10000)
stop_sound()

-- 脚本结束 / 停止前确保不再有声音（脚本停止时 App 也会自动释放）
stop_sound()

-- 默认顶部显示
show_message("任务开始执行")

-- 预设位置 + 时长
show_message("任务完成！", "bottom", 5000)

-- 坐标定位：(x,y) 为消息框中心（自动缩放适配分辨率）
show_message("⚠️ 血量不足，请注意！", 600, 300, 3000)

-- 坐标定位（table 写法）
show_message("检测到BOSS", {x = 640, y = 200}, 2000)

toast("操作完成")

runApp("com.tencent.mm")
stopApp("com.tencent.mm")

-- ============================================================
-- clearAppData(包名) -> boolean
-- 清空应用「全部数据」= 系统 设置 → 应用 → 存储 → 清除数据：
-- 登录账号 / SharedPreferences / 数据库 / files / cache 全部删除，
-- 目标应用回到「刚安装」状态，下次打开需要重新登录（换号、清缓存常用）。
-- 需要 root 或 App 是设备所有者（Android 9+）；普通未 root 设备返回 false。
-- ============================================================

-- 用一个函数收口，避免「单个清 / 批量清」写两遍
local function clearAndRelaunch(pkg, relaunch)
    if pkg == nil or pkg == "" then
        log("包名为空，跳过")
        return false
    end
    -- ① 目标在跑就先关掉：个别机型「边写边清」会清不干净（pm clear 内部也会 force-stop，这里只是兜底）
    stopApp(pkg)
    sleep(300)
    -- ② 清数据：系统确认成功才返回 true
    if not clearAppData(pkg) then
        log("❌ " .. pkg .. " 清除失败：包名写错 / 没有 root 且不是设备所有者 / 目标不存在")
        return false
    end
    log("✅ " .. pkg .. " 已清除（账号已退出），下次打开需要重新登录")
    -- ③ 要重开就等系统把数据目录清干净再启动，清完立刻 runApp 有可能起不来
    if relaunch then
        sleep(1500)
        runApp(pkg)
    end
    return true
end

-- 单个游戏：清数据 → 重新打开（重开后会停在登录页）
clearAndRelaunch("com.example.game", true)

-- 批量清理（模拟器多开 / 换号常用）：只清不重开，最后统一报告结果
local pkgs = {
    "com.example.game",
    "com.example.game2",
    "com.example.game3",
}
local okCount = 0
local failList = {}
for i = 1, #pkgs do
    if clearAndRelaunch(pkgs[i], false) then
        okCount = okCount + 1
    else
        failList[#failList + 1] = pkgs[i]
    end
    sleep(300)   -- 批量时给系统一点缓冲，避免连续清理互相打架
end
log(string.format("批量清理完成：成功 %d / 共 %d", okCount, #pkgs))
if #failList > 0 then
    log("失败：" .. table.concat(failList, ", "))
end

-- 防呆：包名为空 / 带空格、分号等字符会直接返回 false，不会拼进 root 命令
log(tostring(clearAppData()))                  -- false
log(tostring(clearAppData("com.foo;reboot")))  -- false

-- 1) 改完需要冷启动才生效的配置，让 App 自己重启（重启后手动点「启动脚本」）
restartApp()   -- 这一行后面的代码不会执行

-- 2) 重启完自动继续跑（改完截图模式 / 输入法 / 包内脚本后用这个）
show_message_keep("配置已保存，2 秒后自动重启并继续运行...", 600, 300)
sleep(2000)
restartApp(true)   -- 新进程起来后自动帮你点一次「启动脚本」

-- 3) 放进停止回调：收尾 + 重启（并自动继续运行）一条龙
setStopCallBack(function(error)
    imeLib.unlock()        -- 解锁古龙输入法
    close_message_keep()   -- 关掉驻留消息窗
    restartApp(true)       -- 收尾完成后重启，并自动继续运行
end)

local pkg = frontAppName()
if appIsFront("com.example.game") then
    log("游戏在前台")
end

writePasteboard("123")
local text = readPasteboard()

local num = rnd(1, 100)
local x = rnd(100, 500)   -- 随机点击位置

local w, h = getDisplaySize()
tap(w / 2, h / 2)  -- 点击屏幕中心

setControlBarPosNew(0, 0)        -- 左上角
setControlBarPosNew(1.0, 0)      -- 右上角
setControlBarPosNew(0.5, 0.5)    -- 屏幕中心

local y, m, d, h, mi, s = get_current_time()
log(string.format("%d-%02d-%02d %02d:%02d:%02d", y, m, d, h, mi, s))

local hours = get_uptime() / 3600000

-- 1) 创建并显示第1行（默认），坐标 (600,300) 为第1行位置
show_message_keep("状态: 运行中", 600, 300)

-- 2) 更新第1行内容（其他行不受影响）
show_message_keep("状态: 打怪中 12:30")

-- 3) 第2行（显示在第1行上面），坐标省略 → 沿用上次位置
show_message_keep("血量: 980/1200", nil, nil, 2)

-- 4) 第3行写在第2行上面
show_message_keep("金币: 12,345", nil, nil, 3)

-- 5) 只给一个数字 → 视为行号（更新第4行）
show_message_keep("经验: 15%", 4)

-- 6) table 写法：位置 + 行号一起指定
show_message_keep("BOSS 已刷新", {x = 600, y = 300, line = 5})

-- 7) 清空某一行（例如 BOSS 消失后）
show_message_keep("", nil, nil, 5)

-- 8) 用完后销毁整个驻留消息窗
close_message_keep()

-- ===== 典型循环用法（10秒刷新一次血量，全程不闪屏）=====
show_message_keep("自动挂机中", 60, 400)     -- 第1行：固定位置
while true do
    local hp = get_color(100, 100)            -- 你自己的取值逻辑
    show_message_keep("血量: " .. tostring(hp), nil, nil, 2)
    show_message_keep("金币: " .. tostring(os.time()), nil, nil, 3)
    sleep(1000)
end
-- 脚本正常结束时记得清理：close_message_keep()

-- 9) 推荐收尾：只要用了驻留窗，就顺手注册一个停止回调，
--    这样「手动点停止 / 脚本跑完 / 脚本报错退出」都会自动把窗口关掉（不会残留在屏幕上）
setStopCallBack(function(error)
    imeLib.unlock()                                        -- 解锁古龙输入法，恢复系统输入法
    close_message_keep()                                   -- 关闭驻留消息窗
    execRoot("settings put global policy_control null")    -- 恢复状态栏显示
end)

-- 先显示驻留面板
show_message_keep("自动挂机中", 60, 400)
show_message_keep("血量: 1200/1200", nil, nil, 2)

-- 任务结束时关闭
close_message_keep()
show_message("任务完成！", "bottom", 3000)   -- 需要短暂提示可以用 show_message

-- ===== 推荐：写进停止回调，脚本无论怎么结束都会自动关闭 =====
-- 手动点「停止」时，脚本末尾那行 close_message_keep() 根本走不到，窗口会残留在屏幕上；
-- 放进 setStopCallBack 后：手动停止 / 脚本跑完 return / 脚本报错退出，都会自动关掉
setStopCallBack(function(error)
    imeLib.unlock()                                        -- 解锁古龙输入法，恢复系统输入法
    close_message_keep()                                   -- 关闭驻留消息窗
    execRoot("settings put global policy_control null")    -- 恢复状态栏显示
end)

-- 1) 最简用法：两个按钮都显示，脚本暂停等你选择
local ret = show_dialog("请手动完成登录，完成后点「继续运行」")
if ret then
    log("用户选择继续，脚本继续执行")
end

-- 2) 自定义标题（第 2 个参数传字符串）
show_dialog("检测到验证码，请手动输入", "人工确认")

-- 3) 只显示「继续运行」（隐藏左下角停止按钮）
local ok = show_dialog("请确认背包已清空", {stop = false})

-- 4) 只显示「停止脚本」，并自定义按钮文字
show_dialog("账号异常，脚本需要停止", {resume = false, stop_text = "退出脚本"})

-- 5) 超时自动继续（5 秒没操作就继续跑）
show_dialog("BOSS 即将刷新，是否等待？", {timeout = 5000, timeout_action = "resume"})

-- 6) 坐标定位 + 不显示任何按钮（点按弹窗任意位置继续）
show_dialog("脚本已暂停（点我继续）", {stop = false, resume = false, x = 640, y = 360})

-- 7) 典型用法：异常时询问用户，按选择决定去留
local ret = show_dialog("检测到角色死亡，\n是否继续挂机？", {
    title       = "运行提示",
    stop_text   = "停止脚本",
    resume_text = "继续挂机"
})
if ret then
    log("继续挂机")
else
    log("用户选择停止")
end

-- 8) 想自己做善后处理：用 stop_action="return" 拿到 false，再决定去留
local ret = show_dialog("检测到异常，是否继续？", {
    stop_action = "return"        -- 点「停止脚本」时只返回 false，平台不强制停止
})
if ret then
    log("继续执行")
else
    log("用户要求停止，做善后处理后自己结束脚本")
    close_message_keep()          -- 例如：清理驻留面板
    return
end

-- 查看系统信息
local info = execRoot("cat /proc/version")
print("系统版本: " .. info)

-- 获取当前用户
print("当前用户: " .. execRoot("whoami"))

-- 查看进程列表
print(execRoot("ps -A"))

-- 隐藏状态栏（完全沉浸式，* 表示所有应用）
execRoot("settings put global policy_control immersive.full=*")
-- 恢复状态栏显示
execRoot("settings put global policy_control null")

-- 查看当前已隐藏的状态栏图标
local hidden = shell("settings get secure icon_blacklist")
print("已隐藏图标: " .. hidden)

-- 隐藏蓝牙与QQ图标（无需root，Android 6.0+）
shell("settings put secure icon_blacklist bluetooth,qq")

-- 查看所有支持隐藏的图标名称
print(shell("cmd statusbar get-status-icons"))

-- 隐藏所有应用的状态栏（如需写权限请改用 execRoot）
shell("settings put global policy_control immersive.status=*")

-- 1) 立即重启（默认 1 秒后），重启后手动重新启动脚本
local ok = rebootSystem()
if not ok then
    log("当前设备无法重启：需要 root / 设备所有者 / 系统签名")
end

-- 2) 留 3 秒收尾，重启后自动继续跑（无人值守脚本推荐）
show_message_keep("设备将在 3 秒后重启…", 600, 300)
rebootSystem(3000, true)
-- 真机上这一行通常不会执行：delay 到点后脚本会被停止并重启设备
-- 模拟器 / 虚拟机上会重启古龙自身进程，系统不重启、画面不停

-- 3) 防重启循环：90 秒内只受理一次，冷却期内的第二次一定返回 false
--    （重启后自动继续运行、脚本又跑到这里时，不会把设备再重启一遍）
local again = rebootSystem()
if not again then
    log("距上次受理重启不到 90 秒，这次不重启")
end

-- 4) 模拟器 / 虚拟机上不会重启系统：改为重启古龙自身进程（画面一秒不停），
--    顺带把游戏 force-stop，下次进游戏就回到登录 / 主界面
rebootSystem(2000, true, "auto", "com.xxx.game")

-- 5) 只想重启古龙自身进程：任何设备都画面不停，也不需要 root
rebootSystem(1000, true, "app")

-- 6) 软重启安卓框架 + 重启后亮屏解锁（需要 root）
--    没有 root 时自动降级为 app / hard，日志里会写明
rebootSystem(2000, true, "soft", nil, {
    wake_screen = true,          -- soft / hard 档默认就是 true，显式写更清楚
    settle_ms = 5000,           -- 仅 app 档生效；soft / hard 由公共设置倒计时决定
    clean_memory = true,       -- 重启前顺手回收内存缓存
    kill_background = true      -- 重启前清一次后台进程
})

-- 7) 参数多时可以用单表形式，含义和位置参数完全一样
rebootSystem{
    delay_ms = 3000,
    continue_run = true,
    mode = "app",
    stop_app = { "com.xxx.game", "com.yyy.game" },
    opts = { settle_ms = 3000 }
}

-- ① 已有 "ip:port"（最常用）
set_proxy("1.2.3.4:8888")

-- ② IP 和端口分开
set_proxy("1.2.3.4", 8888)

-- ③ 写完顺便重启游戏
set_proxy("1.2.3.4:8888", nil, "com.xxx.game")

-- ④ table 写法：把 fetch_proxy 拿到的地址直接丢进来
local addr = fetch_proxy()
if addr then
    set_proxy({ip = addr, package = "com.xxx.game"})
end

-- 看看现在走的是直连还是代理
local p = get_proxy()
if p then
    log(string.format("当前代理 %s（%s:%d）", p.address, p.host, p.port))
else
    log("当前直连")
end

-- 换号前先判断：已经是目标代理就不用重设（省时间也省代理时长）
local target = "1.2.3.4:8888"
if not p or p.address ~= target then
    set_proxy(target, nil, "com.xxx.game")
    sleep(8000)
end

-- ① 只清代理（脚本收尾用，避免影响别的软件）
clear_proxy()

-- ② 清完并重启游戏，立刻恢复直连
clear_proxy("com.xxx.game")

-- ③ 这个号被限制：先摘代理 → 重新换一个 IP → 再登录
clear_proxy("com.xxx.game")
sleep(5000)
set_proxy("5.6.7.8:9999", nil, "com.xxx.game")
sleep(8000)
login(username, password)

-- ① 用自己的提取链接（设备端必须显式传）
local addr = fetch_proxy(API_URL)
if addr then log("提到代理: " .. addr) end

-- ② 用自己的链接，一次提 3 个（只取第一个）
local one = fetch_proxy("http://api.xiequ.cn/VAD/GetIp.aspx?act=get&uid=xxx&vkey=xxx&num=3&spl=1", 3)

-- ③ 提取 + 写入 + 重启，自己控制流程（等价于 switch_proxy_ip）
-- API_URL = 你的携趣提取链接常量（见本节「提取链接配置」）
local addr2 = fetch_proxy(API_URL)
if addr2 then
    set_proxy(addr2, nil, "com.xxx.game")
    sleep(10000)
    login(username, password)
end

-- ① 传链接 + 重启游戏
local addr = switch_proxy_ip(API_URL, "com.xxx.game")
if addr then
    log("已换 IP: " .. addr)
    sleep(10000)            -- 等游戏起来
else
    log("换 IP 失败，本次直连登录")
end

-- ② 用自己的链接、跳过校验（快，但可能拿到死 IP）
switch_proxy_ip(API_URL, "com.xxx.game", 1, false)

-- ③ 每个账号换一次 IP
for i, account in ipairs(accounts) do
    local one = switch_proxy_ip(API_URL, "com.xxx.game", 2, true, 15)
    if not one then
        log(string.format("[%d/%d] 换 IP 失败，跳过 %s", i, #accounts, account))
    else
        log(string.format("[%d/%d] %s 走 %s", i, #accounts, account, one))
        sleep(10000)
        login(account, passwords[i])
        sleep(30000)        -- 做完任务
    end
end

-- ① 查本机出口 IP（做对比基线）
log("本机出口: " .. proxy_out_ip())

-- ② 验证刚提取的代理能不能出网
local a = fetch_proxy(API_URL)
if a then
    local ip = proxy_out_ip(a)
    log(ip == "" and ("代理不可用: " .. a) or ("出口 IP: " .. ip))
end

-- ③ 换 IP 前后对比
local before = proxy_out_ip()
local addr = switch_proxy_ip(API_URL, "com.xxx.game")
log(string.format("换 IP: %s -> %s", before, proxy_out_ip(addr)))

-- ④ table 写法：带账密（携趣隧道代理）
log(proxy_out_ip({host = "1.2.3.4", port = 8888, user = "u", pass = "p"}))

-- ===== 1) 最简用法：拿基址 + 判断失败 =====
local base = GetModuleHandle("com.example.game", "libunity.so")
if base == nil then
    log("取模块基址失败：请检查包名 / 模块名 / root 权限（原因见日志上一行）")
    return
end
log(string.format("libunity.so 基址 = 0x%X（十进制 %.0f）", base, base))

-- ===== 2) 拿到基址后按偏移读写（偏移来自逆向分析，下面这些都是编造的示例值） =====
local hpAddr = base + 0x1A2B3C
log(string.format("血量地址 = 0x%X", hpAddr))
log("当前血量 = " .. tostring(MemoryRead(hpAddr, "I32")))
MemoryWrite(hpAddr, 99999, "I32")
log("修改后血量 = " .. tostring(MemoryRead(hpAddr, "I32")))

-- ===== 3) 模块名不确定？先列出目标进程加载的所有 so =====
local pid = execRoot("pidof com.example.game"):gsub("%s+$", "")   -- 去掉末尾换行
if pid == "" then
    log("进程没在运行（或没有 root，列不出别的进程）")
else
    log(execRoot("cat /proc/" .. pid .. "/maps | awk '{print $6}' | sort -u | grep '[.]so$'"))
end
-- 输出示例（每行一个模块路径）：
--   /data/app/~~xxxx/com.example.game-xxxx/lib/arm64/libunity.so
--   /data/app/~~xxxx/com.example.game-xxxx/lib/arm64/libil2cpp.so
-- 取路径最后一段文件名就是模块名：GetModuleHandle("com.example.game", "libil2cpp.so")

-- ===== 4) 一次取多个模块并缓存复用（推荐写法） =====
local Game = {}
Game.pkg = "com.example.game"
Game.unity = GetModuleHandle(Game.pkg, "libunity.so")
Game.il2cpp = GetModuleHandle(Game.pkg, "libil2cpp.so")
if Game.unity == nil then
    log("libunity.so 没取到：确认已 root、且游戏已经启动")
    return
end
log(string.format("unity = 0x%X，il2cpp = %s", Game.unity,
    Game.il2cpp and string.format("0x%X", Game.il2cpp) or "未加载"))
-- 基址在「本次运行」里不会变：一个脚本只取一次、放进表里反复用（别放在每帧循环里反复调用）

-- ===== 5) 只传一个参数 = 当前 App 自身进程（免 root 也可能成功） =====
local selfLibc = GetModuleHandle("libc.so")
log("自身进程 libc.so 基址 = " .. tostring(selfLibc))

-- ===== 6) 冒烟测试：不碰游戏，验证「读内存」这条链路通不通 =====
local libc = GetModuleHandle("libc.so")
if libc then
    -- ELF 文件头前 4 字节固定是 7F 45 4C 46（0x7F 后面跟 "ELF"）
    log("ELF 魔数 = " .. tostring(MemoryRead(libc, "HEX", nil, 4)))   -- 期望输出 7F 45 4C 46
else
    log("连自身 libc.so 都取不到：shell 通道 / 权限有问题")
end

-- ===== 7) 偏移集中管理，脚本更好维护 =====
local OFF = {
    hp   = 0x1A2B3C,   -- 血量 (I32)
    gold = 0x1A2B40,   -- 金币 (U32)
    posX = 0x1A2B50,   -- 坐标 X (FLOAT)
    posY = 0x1A2B54,   -- 坐标 Y (FLOAT)
    name = 0x1A2B60,   -- 角色名 (STRING，最多 32 字节)
}
log("血量 = " .. tostring(MemoryRead(base + OFF.hp, "I32")))
log("金币 = " .. tostring(MemoryRead(base + OFF.gold, "U32")))
log(string.format("坐标 = (%.1f, %.1f)",
    MemoryRead(base + OFF.posX, "FLOAT"), MemoryRead(base + OFF.posY, "FLOAT")))
log("角色名 = " .. tostring(MemoryRead(base + OFF.name, "STRING", nil, 32)))

-- ===== 8) 多级指针：基址 → 对象指针 → 字段（逆向里最常见的形态） =====
-- 例：base + 0x30 里存着玩家对象地址，对象 + 0x18 里存着血量
local p1 = MemoryRead(base + 0x30, "U64")     -- 64 位进程指针是 8 字节用 U64；32 位进程用 U32
if p1 then
    local p2 = MemoryRead(p1 + 0x18, "U64")
    if p2 then
        log("玩家血量 = " .. tostring(MemoryRead(p2 + 0x10, "I32")))
    else
        log("第二级指针为空：对象还没创建（进游戏 / 开一局后再读）")
    end
end

-- ===== 9) 模块还没加载？循环重试 =====
local base2, tries = nil, 0
while base2 == nil and tries < 10 do
    base2 = GetModuleHandle("com.example.game", "libil2cpp.so")
    if base2 == nil then
        tries = tries + 1
        log("第 " .. tries .. " 次没取到，1 秒后重试…")
        sleep(1000)
    end
end
log("重试 " .. tries .. " 次后基址 = " .. tostring(base2))

-- ===== 10) 常见坑 =====
-- ① 基址只对「本次运行」有效：游戏重启 / 进程被杀后基址会变，脚本每次启动都要重新 GetModuleHandle。
-- ② 别把自己 log 出来的基址写死在脚本里，换台设备或重启就失效了。
-- ③ 包名不是应用名：用「应用管理」或 execRoot("pm list packages | grep 关键字") 确认真实包名。
-- ④ 模块名区分大小写：libUnity.so 和 libunity.so 不是同一个文件。
-- ⑤ 想要游戏没启动也能取基址是做不到的：模块必须先被加载进内存。

-- 准备：先拿基址（下面所有偏移都是编造的示例值，请换成你自己分析出来的）
local base = GetModuleHandle("com.example.game", "libunity.so")
if base == nil then
    log("先解决基址问题（见 GetModuleHandle 的示例）")
    return
end

-- ===== 1) 四种基础读法 =====
log("血量(I32)   = " .. tostring(MemoryRead(base + 0x1A2B38, "I32")))
log("金币(U32)   = " .. tostring(MemoryRead(base + 0x1A2B3C, "U32")))
log("坐标X(FLOAT)= " .. tostring(MemoryRead(base + 0x1A2B40, "FLOAT")))
log("倍率(DOUBLE)= " .. tostring(MemoryRead(base + 0x1A2B48, "DOUBLE")))

-- ===== 2) 同一个地址用不同类型读，理解「类型 / 字节数」 =====
local addr = base + 0x2000
log("HEX   = " .. tostring(MemoryRead(addr, "HEX", nil, 8)))   -- 先看原始字节，例如 F4 01 00 00 00 00 00 00
log("U8    = " .. tostring(MemoryRead(addr, "U8")))            -- 只看第 1 个字节 → 244
log("U16   = " .. tostring(MemoryRead(addr, "U16")))           -- 前 2 字节 → 500
log("U32   = " .. tostring(MemoryRead(addr, "U32")))           -- 前 4 字节 → 500
log("FLOAT = " .. tostring(MemoryRead(addr, "FLOAT")))         -- 同样 4 字节按 float 解释 → 约 7e-43（一眼就是类型不对）
-- 结论：读出来的数值「离谱」，多半是类型挑错了；用 HEX 对一下就知道真实存放格式

-- ===== 3) 有符号与无符号的差别（同一块内存，两种读法） =====
-- 内存里 4 个字节是 FF FF FF FF 时：
--   I32 读 → -1
--   U32 读 → 4294967295
-- 内存里 1 个字节是 F4 时： I8 读 → -12，U8 读 → 244

-- ===== 4) 读字符串（默认 64 字节，遇到 0 结束符截断） =====
log("角色名 = " .. tostring(MemoryRead(base + 0x2100, "STRING")))            -- 默认读 64 字节
log("公会名 = " .. tostring(MemoryRead(base + 0x2140, "STRING", nil, 32)))   -- 只读 32 字节，更快也更安全
-- 中文没问题（按 UTF-8 解码）；读到的比预期短，通常是原数据里本来就有 0 字节

-- ===== 5) 读原始字节，和内存工具对照 =====
log(tostring(MemoryRead(base + 0x2000, "HEX", nil, 16)))   -- 16 字节 = 内存视图的一行
log(tostring(MemoryRead(base + 0x2000, "HEX", nil, 64)))   -- 64 字节，看整体结构

-- ===== 6) 多级指针（实战里最常用） =====
local function readPtr(a) return MemoryRead(a, "U64") end   -- ARM64 指针 8 字节
local p1 = readPtr(base + 0x30)                            -- 第一级
if p1 then
    local p2 = readPtr(p1 + 0x18)                          -- 第二级
    if p2 then
        log("玩家血量 = " .. tostring(MemoryRead(p2 + 0x10, "I32")))
        log("玩家名字 = " .. tostring(MemoryRead(p2 + 0x20, "STRING", nil, 32)))
    else
        log("第二级指针为空：对象还没创建（回到游戏里再试）")
    end
end

-- ===== 7) 读连续数组：按步长循环 =====
-- 例：背包 10 个格子的物品 ID（U32，相邻元素间隔 4 字节）
local bagAddr = base + 0x3000
local ids = {}
for i = 0, 9 do
    ids[#ids + 1] = tostring(MemoryRead(bagAddr + i * 4, "U32"))
end
log("背包物品ID = " .. table.concat(ids, ", "))

-- ===== 8) 读结构体数组：元素大小 + 字段偏移 =====
-- 例：每个怪物 0x50 字节，血量在元素内偏移 4，等级在偏移 0x0C
for i = 0, 2 do
    local e = base + 0x4000 + i * 0x50
    log(string.format("怪物%d：血量=%s 等级=%s", i + 1,
        tostring(MemoryRead(e + 4, "I32")), tostring(MemoryRead(e + 0x0C, "I32"))))
end

-- ===== 9) 读坐标（3 个连续 float：x, y, z） =====
local x = MemoryRead(base + 0x1A2B50, "FLOAT")
local y = MemoryRead(base + 0x1A2B54, "FLOAT")
local z = MemoryRead(base + 0x1A2B58, "FLOAT")
log(string.format("坐标 = (%.2f, %.2f, %.2f)", x, y, z))

-- ===== 10) 读失败给默认值，避免脚本被 nil 打断 =====
local function readOr(addr, t, def)
    local v = MemoryRead(addr, t)
    if v == nil then return def end
    return v
end
log("金币（读失败就按 0 显示）= " .. tostring(readOr(base + 0x1A2B3C, "U32", 0)))
-- 注意：nil 参与算术会报错（attempt to perform arithmetic on a nil value），拿到值先判断再用

-- ===== 11) 轮询监控数值变化（1 秒一次，共 10 次） =====
local last = nil
for i = 1, 10 do
    local hp = MemoryRead(base + 0x1A2B38, "I32")
    if hp ~= last then
        log(string.format("[%d] 血量变化：%s → %s", i, tostring(last), tostring(hp)))
        last = hp
    end
    sleep(1000)
end

-- ===== 12) 省略包名 = 沿用上一次目标；显式传包名 = 固定目标 =====
local selfBase = GetModuleHandle("libc.so")          -- 只传一个参数 → 当前 App 自身进程
if selfBase then
    log("自身进程 ELF 魔数 = " .. tostring(MemoryRead(selfBase, "HEX", nil, 4)))   -- 7F 45 4C 46
end
log("指定包名读同一个地址 = " .. tostring(MemoryRead(base + 0x1A2B3C, "U32", "com.example.game")))

-- ===== 13) 读不到？按顺序排查 =====
local v = MemoryRead(base + 0x1A2B3C, "I32")
if v == nil then
    log("① 偏移是不是这个游戏版本的（更新后偏移会变）")
    log("② 目标进程还活着吗：" .. tostring(execRoot("pidof com.example.game")))
    log("③ 换成 HEX 读同一地址：" .. tostring(MemoryRead(base + 0x1A2B3C, "HEX", nil, 16)))
    log("④ 是否已 root 并授权 su；对象是否还没创建")
end

-- 推荐模式：先读 → 判断 → 写 → 回读验证
local base = GetModuleHandle("com.example.game", "libunity.so")
if base == nil then
    log("先拿到基址再写（见 GetModuleHandle 示例）")
    return
end
local HP = base + 0x1A2B38

-- ===== 1) 标准写法：读 → 写 → 验证 =====
local old = MemoryRead(HP, "I32")
log("原血量 = " .. tostring(old))
if old == nil then
    log("连读都读不到，先排查地址 / 权限，别急着写")
    return
end
if MemoryWrite(HP, 99999, "I32") then
    log("写入成功，现在血量 = " .. tostring(MemoryRead(HP, "I32")))   -- 99999
else
    log("写入失败（原因见日志上一行）")
end

-- ===== 2) 各种类型怎么写 =====
MemoryWrite(base + 0x1A2B38, 1000, "I32")          -- 整数
MemoryWrite(base + 0x1A2B3C, -1, "I32")            -- 有符号负数（内存里是 FF FF FF FF）
MemoryWrite(base + 0x1A2B40, 0.5, "FLOAT")         -- 浮点
MemoryWrite(base + 0x1A2B48, 1.25, "DOUBLE")       -- 双精度
MemoryWrite(base + 0x1A2B50, "0x1F4", "U32")       -- 十六进制字符串写法：0x1F4 = 500
MemoryWrite(base + 0x1A2B54, "8888.5", "FLOAT")    -- 数字字符串也行
MemoryWrite(base + 0x1A2B60, "古龙", "STRING")      -- UTF-8 文本（不自动补 0，别比原值长）
MemoryWrite(base + 0x1A2B70, "90909090", "HEX")    -- 4 个 NOP 字节
MemoryWrite(base + 0x1A2B74, "00 00 00 00", "HEX") -- 用空格分隔的写法更直观
MemoryWrite(base + 0x1A2B78, "0x1F4", "HEX")       -- HEX 写数字：按 4 字节小端写出

-- ===== 3) 写坐标（3 个连续 float，步长 4） =====
local function writePos(addr, x, y, z)
    if not MemoryWrite(addr, x, "FLOAT") then return false end
    if not MemoryWrite(addr + 4, y, "FLOAT") then return false end
    return MemoryWrite(addr + 8, z, "FLOAT")
end
if writePos(base + 0x1A2B50, 100.5, 200.0, 0) then
    log("坐标已写入")
end

-- ===== 4) 批量写入：连续数组 =====
local bagAddr = base + 0x3000
local okCount = 0
for i = 0, 9 do
    if MemoryWrite(bagAddr + i * 4, 1000 + i, "U32") then
        okCount = okCount + 1
    else
        log("第 " .. (i + 1) .. " 个格子写入失败：" .. string.format("0x%X", bagAddr + i * 4))
    end
end
log(string.format("背包写入成功 %d/10", okCount))

-- ===== 5) 写完立刻看内存原貌，确认字节序 =====
MemoryWrite(base + 0x1A2B3C, 500, "U32")
log("500 写进去后内存 = " .. tostring(MemoryRead(base + 0x1A2B3C, "HEX", nil, 4)))   -- F4 01 00 00

-- ===== 6) 备份 → 临时修改 → 恢复（练习时推荐） =====
local backup = MemoryRead(HP, "I32")
if backup ~= nil then
    MemoryWrite(HP, 1, "I32")        -- 临时改成 1
    log("已临时修改，3 秒后恢复…")
    sleep(3000)
    MemoryWrite(HP, backup, "I32")
    log("已恢复为原值 " .. tostring(MemoryRead(HP, "I32")))
end

-- ===== 7) 封装：写失败自动重试（对象还没创建时特别有用） =====
local function writeRetry(addr, v, t, times)
    times = times or 5
    for i = 1, times do
        if MemoryWrite(addr, v, t) then return true end
        log("第 " .. i .. " 次写入失败，1 秒后重试…")
        sleep(1000)
    end
    return false
end
if not writeRetry(base + 0x1A2B38, 50000, "I32") then
    log("多次都失败：地址可能只读 / 已失效（对象被销毁、游戏版本变了）")
end

-- ===== 8) 一次性把结果写进日志，便于观察 =====
local function tryWrite(addr, v, t)
    local before = MemoryRead(addr, t)
    local ok = MemoryWrite(addr, v, t)
    local after = MemoryRead(addr, t)
    log(string.format("写 %s → %s ：%s（%s → %s）", t, tostring(v), ok and "成功" or "失败",
        tostring(before), tostring(after)))
    return ok
end
tryWrite(base + 0x1A2B3C, 12345, "U32")

-- ===== 9) 写了「没用」？按这几种情况排查 =====
-- ① 值被游戏持续回写：改成循环里连续写几次验证
local loopAddr = base + 0x1A2B38
local writes = 0
for i = 1, 10 do
    if MemoryWrite(loopAddr, 9999, "I32") then writes = writes + 1 end
    sleep(200)
end
log("连续写入成功 " .. writes .. " 次；若界面数值仍不动，说明这不是生效的字段")
-- ② 类型写错：float 字段用 I32 写进去，读出来是「乱码」数值 → 用 HEX 对照原内存
-- ③ 地址在只读页（.rodata / 代码段）：找存放该值的可写副本，或改指针链上游
-- ④ 游戏更新后偏移变化 / 基址变化：脚本每次运行都要重新取基址、重新核对偏移

-- ① 检查无障碍是否连上：refresh() 返回当前界面节点总数，-1 = 取不到窗口
local total = nodeLib.refresh()
if total <= 0 then
    toast("请先开启「古龙精灵」无障碍服务")
    return
end
log("当前界面共 " .. total .. " 个节点")

-- ② 等按钮出现：最多 15 秒，第 3 个参数 true = 模糊匹配（"开始" 也能命中「点击开始」）
local startBtn = nodeLib.waitFor({text="开始游戏", clickable=true}, 15000, true)
if startBtn == nil then
    log("15 秒没等到按钮：确认游戏在前台，或用 nodeLib.getXml() 看真实文本")
    return
end

-- ③ 点击：返回 true 只表示「动作已发给系统」，不代表页面一定跳转
if not nodeLib.click(startBtn) then
    log("点击失败：无障碍被系统回收，或节点已经消失")
    return
end

-- ④ 等新页面：用「新页面独有」的节点判断，不要去等刚才那个按钮消失
local bag = nodeLib.waitFor({text="背包"}, 10000, true)
if bag ~= nil then
    log("已进入主界面，背包入口中心点: " .. bag.cx .. "," .. bag.cy)
else
    log("点击后 10 秒没看到主界面：可能弹了公告，先跑下面「一键关弹窗」配方")
end

-- 场景 1：最普通的点击（先判空 → 点 → 看返回值）
local node = nodeLib.findOne({class="android.widget.Button", text="确定"})
if node ~= nil then
    if not nodeLib.click(node) then
        log("点击失败：无障碍没连上，或节点已经消失")
    end
end

-- 场景 2：点之前先确认「看得见 + 没被禁用」，避免点到隐藏节点
local btn = nodeLib.findOne({text="领取", clickable=true}, true)
if btn ~= nil and btn.visible and btn.enabled then
    nodeLib.click(btn)
else
    log("领取按钮不可见或被禁用，奖励可能还没到账")
end

-- 场景 3：无障碍点不动时的最后兜底 —— 用节点中心点坐标点击
local close = nodeLib.findOne({desc="关闭"}, true)
if close ~= nil and not nodeLib.click(close) then
    log("节点点击失败，改用坐标: " .. close.cx .. "," .. close.cy)
    tap(close.cx, close.cy)
end

-- 场景 4：长按（删除、拖动、查看详情）—— 第 2 个参数是毫秒数
local item = nodeLib.findOne({text="强化石"}, true)
if item ~= nil then
    nodeLib.click(item, 800)       -- 先 ACTION_LONG_CLICK，失败自动 longTap
end

-- 场景 5：已经知道路径时直接点（最快，省一次查找；结构变了会失败）
nodeLib.click("0|1|2")

-- 写法 1：精确匹配（节点工具勾选出来的写法，id / class 一字不差）
local n1 = nodeLib.findOne({class="android.widget.TextView", text="名称: tmp.lr"})

-- 写法 2：模糊匹配 + 可点击（文本「包含」确定，且节点本身可点）
local n2 = nodeLib.findOne({text="确定", clickable=true}, true)

-- 写法 3：模糊 + 通配符（id 可省略包名，btn_* 能匹配 com.xxx:id/btn_ok）
local n3 = nodeLib.findOne({id="btn_*"}, true)

-- 写法 4：简写（等价于 {text="开始游戏"}，完全相等，不带模糊）
local n4 = nodeLib.findOne("开始游戏")
if n4 ~= nil then
    log("找到: " .. n4.label .. " 中心点 " .. n4.cx .. "," .. n4.cy)
end

-- 写法 5：文字为空时，用 contentDescription（desc）找图标按钮
local close = nodeLib.findOne({desc="关闭"}, true)

-- 写法 6：用输入框提示（hint）定位输入框，比 class 更准
local edit = nodeLib.findOne({editable=true, hint="请输入"}, true)

-- 写法 7：同名节点太多？加深度区间，避开列表里重复的标题
local title = nodeLib.findOne({class="android.widget.TextView", text="背包", min_depth=2, max_depth=6})

-- 写法 8：找不到时别靠猜 —— 把可点击节点的 label 全打出来，看真实文本长什么样
if nodeLib.findOne({text="领取"}) == nil then
    local all = nodeLib.findAll({clickable=true})
    for i = 1, #all do
        log("候选 " .. i .. ": [" .. all[i].label .. "] class=" .. all[i].class)
    end
end

-- ① 找出所有可点击按钮，打印数量与位置
local list = nodeLib.findAll({class="android.widget.Button", clickable=true})
log("共找到 " .. list.n .. " 个按钮")
for i = 1, #list do
    local node = list[i]
    log(i .. ": " .. node.label .. " @ " .. node.cx .. "," .. node.cy)
end

-- ② 按屏幕位置排序（列表控件返回顺序不一定是视觉顺序时很有用）
table.sort(list, function(a, b)
    if a.top ~= b.top then return a.top < b.top end
    return a.left < b.left
end)

-- ③ 只要某一个：第 3 个 / 随机一个（「随机点一个商品」很常用）
if #list >= 3 then nodeLib.click(list[3]) end
if #list > 0 then nodeLib.click(list[math.random(1, #list)]) end

-- ④ 模糊匹配后逐个点击：点完界面可能重排，所以每次先 refresh 再按文本重找
local tasks = nodeLib.findAll({text="任务"}, true)
for i = 1, #tasks do
    nodeLib.refresh()
    local again = nodeLib.findOne({text=tasks[i].label}, true)
    if again ~= nil then
        nodeLib.click(again)
        sleep(300)
    end
end

-- ⑤ 没找到时是空表（不是 nil）：直接用 # 判断，不会报错
local empty = nodeLib.findAll({text="绝不存在的文字"})
log("数量: " .. #empty)          -- 输出 0

-- 字符串路径：根 → 第 1 个孩子 → 第 2 个孩子（根固定为 0）
local node = nodeLib.findByIndex("0|1|2")
if node ~= nil then
    log("找到: " .. node.label .. " 路径 " .. node.path)
    nodeLib.click(node)
end

-- 数组路径（完全等价）
local same = nodeLib.findByIndex({0, 1, 2})

-- 路径从哪来：findOne 找到后打印 node.path，下次就能直接下钻（最快）
local target = nodeLib.findOne({text="开始游戏"})
if target ~= nil then
    log("这个按钮的路径是: " .. target.path)

    -- 技巧：截掉 path 最后一段 = 父节点路径，可以一次向上取好几层
    local function parentPath(path)
        return string.match(path, "^(.*)|%d+$")
    end
    local p = parentPath(target.path)
    if p ~= nil then
        local row = nodeLib.findByIndex(p)      -- 父节点（通常就是整行）
        if row ~= nil then nodeLib.click(row) end
    end
end

-- 页面结构会变：路径失效时返回 nil，必须准备兜底方案
local fast = nodeLib.findByIndex("0|1|3|0")
if fast == nil then
    log("路径失效（页面结构变了），改用 findOne 重新找")
    fast = nodeLib.findOne({text="开始游戏"}, true)
end
if fast ~= nil then nodeLib.click(fast) end

-- ① 点文字所在整行：文字本身通常不可点，父节点才是真正接收点击的区域
local row = nodeLib.findParentNode({text="银月贤者"}, true)
if row ~= nil then
    log("整行: " .. row.class .. " " .. row.bounds.left .. "," .. row.bounds.top)
    nodeLib.click(row)
else
    log("没有找到「银月贤者」")
end

-- ② 背包格子：按格子里的物品名，点到整个格子（格子可点，名字不可点）
local cell = nodeLib.findParentNode({text="强化石"}, true)
if cell ~= nil and cell.clickable then
    nodeLib.click(cell)
end

-- ③ 父节点也不可点？用 path 一层层往上爬（最多 3 层），谁可点就点谁
local node = nodeLib.findOne({text="每日任务"}, true)
if node ~= nil then
    local path = node.path
    for i = 1, 3 do
        path = string.match(path, "^(.*)|%d+$")   -- 去掉最后一段 = 父节点
        if path == nil then break end          -- 已经是根节点
        local up = nodeLib.findByIndex(path)
        if up == nil then break end
        log("向上第 " .. i .. " 层: " .. up.class .. " clickable=" .. tostring(up.clickable))
        if up.clickable then
            nodeLib.click(up)
            break
        end
    end
end

-- ① 导出完整 XML 到文件（内容很长，不要直接 log 整个字符串）
local xml = nodeLib.getXml()
if xml ~= "" then
    write_file("/sdcard/node_dump.xml", xml)
    log("节点 XML 已保存，共 " .. #xml .. " 字节")
else
    log("取不到节点树：请先开启无障碍服务")
end

-- ② 只想快速看一眼结构：截前 800 个字符打印
if xml ~= "" then
    log(string.sub(xml, 1, 800))
end

-- ③ 写选择器更快的办法：空选择器 = 全部节点，统计都有哪些控件类型
local all = nodeLib.findAll({})
local stat = {}
for i = 1, #all do
    local c = all[i].class
    stat[c] = (stat[c] or 0) + 1
end
for c, n in pairs(stat) do
    log(c .. " × " .. n)
end

-- ④ 相当于「界面文字大纲」：按层级缩进打印所有可见且有文字的节点
for i = 1, #all do
    local nd = all[i]
    if nd.visible and nd.text ~= "" then
        log(string.rep("  ", nd.depth) .. nd.text)
    end
end

-- ① 等「开始游戏」出现，最多等 8 秒（true = 模糊匹配）
local btn = nodeLib.waitFor({text="开始游戏", clickable=true}, 8000, true)
if btn ~= nil then
    nodeLib.click(btn)
else
    log("8 秒内没等到开始按钮，检查是否卡在登录页")
end

-- ② 开屏公告：先等公告出现（5 秒内没有就跳过），再点关闭
local notice = nodeLib.waitFor({text="公告"}, 5000, true)
if notice ~= nil then
    local close = nodeLib.findOne({desc="关闭"}, true)
    if close ~= nil then nodeLib.click(close) end
end

-- ③ 等列表加载完：等某个列表项出现，比 sleep(3000) 稳得多
local item = nodeLib.waitFor({class="android.widget.TextView", text="第 1 名", min_depth=2}, 12000, true)
log(item ~= nil and "排行榜已加载" or "12 秒还没加载出来")

-- ④ 等「消失」：waitFor 做不到，自己轮询（50 次 × 200ms ≈ 10 秒）
for i = 1, 50 do
    nodeLib.refresh()                   -- 轮询必须看最新界面
    if nodeLib.findOne({text="加载中"}, true) == nil then
        log("加载完成")
        break
    end
    sleep(200)
end

-- ① 当「无障碍是否可用」的探针：返回值 <= 0 就是取不到窗口
local total = nodeLib.refresh()
if total <= 0 then
    log("取不到节点树：无障碍没开 / 被系统回收 / 当前是受保护页面")
    return
end
log("当前界面节点数: " .. total)

-- ② 非脚本触发的页面变化（过场动画、倒计时自动跳）之后，先刷新再查
sleep(1500)
nodeLib.refresh()
local bag = nodeLib.findOne({text="背包"}, true)
if bag ~= nil then nodeLib.click(bag) end

-- ③ 反例：click 之后缓存已自动失效，这里不需要再 refresh
local ok = nodeLib.findOne({text="确定"}, true)
if ok ~= nil then
    nodeLib.click(ok)                     -- 点击成功后自动 invalidate
    local next = nodeLib.findOne({text="返回"}, true)   -- 直接查就是新页面
end

local data = json_parse('{"name":"test","value":123}')
log("名称: " .. data.name)  -- 输出: test

local data = {name = "test", value = 123}
local json_str = json_stringify(data)
log(json_str)  -- 输出: {"name":"test","value":123}

-- 用法1：匿名函数（判断_等待服务器出现 放到子线程里跑）
local tid = thread_start(function()
    while true do
        if 综合调用.判断_服务器() then break end
        sleep(100)
    end
end)

-- 用法2：函数名（字符串），需与函数定义同名
-- 注意：脚本里的中文函数名会被自动转成英文标识符，字符串写法会找不到，
--       中文函数请改用函数引用：thread_start(判断_等待服务器出现)
local tid2 = thread_start("judgeServer")

-- 用法3：带参数 + 取返回值
local tid3 = thread_start(function(name, times)
    for i = 1, times do
        log(name .. " 第" .. i .. "次")
        sleep(100)
    end
    return name .. "完成"
end, "打怪", 3)

----主脚本代码写在这里

-- 主脚本继续做别的事，最后统一等待
thread_wait_all()
log(thread_result(tid3))

local tid = thread_start(function() sleep(1000) end)

if thread_wait(tid, 5000) then
    log("线程已结束")
else
    log("等待超时，线程仍在运行")
end

thread_wait()   -- 等待全部子线程

thread_start(function() sleep(500) end)
thread_start(function() sleep(800) end)

if thread_wait_all(10000) then
    log("全部线程结束")
end

local tid = thread_start(function()
    while true do sleep(100) end
end)

sleep(500)
thread_stop(tid)          -- 请求停止
thread_wait(tid, 3000)    -- 等它退出

thread_start(function() while true do sleep(100) end end)
thread_start(function() while true do sleep(100) end end)

local n = thread_stop_all()
log("已停止 " .. n .. " 个线程")

local tid = thread_start(function() sleep(2000) end)
log(tostring(thread_is_running(tid)))  -- true

thread_wait(tid)
log(tostring(thread_is_running(tid)))  -- false

thread_start(function() sleep(1000) end)
thread_start(function() sleep(1000) end)
log("当前线程数: " .. thread_count())  -- 2

thread_wait_all()
log("当前线程数: " .. thread_count())  -- 0

local tid = thread_start(function()
    log("我在子线程 " .. thread_id())  -- 例如 1
end)

log("我在主线程 " .. thread_id())      -- 0
thread_wait(tid)

thread_start(function() sleep(500) end)
thread_start(function() sleep(500) end)
sleep(100)

for i, tid in ipairs(thread_list()) do
    log("存活线程: " .. tid)
end

local tid = thread_start(function()
    sleep(500)
    return "结果A", 123
end)

thread_wait(tid)
local a, b = thread_result(tid)
log(tostring(a) .. ", " .. tostring(b))  -- 结果A, 123

local tid = thread_start(function()
    error("子线程出错了")
end)

thread_wait(tid)
local err = thread_error(tid)
if err then log("线程报错: " .. err) end

计数 = 0

local function 累加()
    for i = 1, 1000 do
        thread_lock()        -- 进入临界区
        计数 = 计数 + 1
        thread_unlock()      -- 离开临界区
    end
end

thread_start(累加)
thread_start(累加)
thread_wait_all()
log("计数 = " .. 计数)       -- 2000（不加锁可能少几次）

thread_lock()
共享变量 = 共享变量 + 1
thread_unlock()

local tid = thread_start(function()
    for i = 1, 3 do
        log("子线程 tick " .. i)
        thread_sleep(300)
    end
end)

log("主线程不受影响，继续执行")
thread_wait(tid)

-- 整包导入（之后直接用包里的类名）
import('java.lang.*')
import('java.util.*')
import('android.content.Context')

print(Math.sin(1.2))                  -- 静态方法：0.932...
print(System.currentTimeMillis())     -- 静态方法（无参）
print(Integer.MAX_VALUE)             -- 静态字段

-- 导入具体类并用短名调用
local StringBuilder = import('java.lang.StringBuilder')
local sb = StringBuilder()            -- 构造对象（等价于 StringBuilder.new()）
sb.append('hello').append(' world')   -- 支持链式调用
log(sb.toString())

-- 导入 Android 类
local Intent = import('android.content.Intent')
local ctx = LuaEngine.getContext()
local it = Intent(ctx, Context.ACTION_VIEW)   -- 也可以 Intent(Context.ACTION_VIEW)
log(tostring(it))

-- Lua table 会自动转成 Java 的 List / Map
local list = import('java.util.ArrayList')()
list.addAll({'a', 'b'})               -- table -> List
log(list.size())                      -- 2
local map = import('java.util.HashMap')()
map.putAll({name = 'gulong', ver = 1})-- table -> Map
log(map.get('name'))

import('android.content.Context')

local ctx = LuaEngine.getContext()
print(ctx.getPackageName())            -- 包名

-- JavaBean 属性写法也支持（等价于 getPackageName()）
print(ctx.packageName)

-- 取系统服务：TelephonyManager / Vibrator / WifiManager ...
local tm = ctx.getSystemService(Context.TELEPHONY_SERVICE)
if tm ~= nil then
    local imei = tm.getImei(0)
    print(imei)
end

-- Application 级上下文（不持有 Service/Activity 引用）
local appCtx = LuaEngine.getApplicationContext()

import('java.lang.*')

-- 1) 插件放在脚本目录，只写名字
local loader = LuaEngine.loadApk('app-release.apk')
if loader == nil then
    log('插件加载失败')
    return
end

-- 2) 加载插件里的类（类里的静态方法/构造/实例方法都能用）
local Plugin = loader.loadClass('com.lrapp.plugin.Plugin')
if Plugin ~= nil then
    print(Plugin.add(1, 2))          -- 静态方法
    local p = Plugin()               -- 构造对象
    print(p.getName())
else
    log('类不存在: ' .. tostring(loader.lastError))
end

-- 3) 插件带 C/C++ 实现时（APK 内 lib/arm64-v8a/libxxx.so）
loader.loadSo('xxx')                 -- 等价于 System.loadLibrary("xxx")
local NativeLib = loader.loadClass('com.xxx.NativeLib')
print(NativeLib.version())

-- 4) 没有 .so 时也可以看一下插件里有哪些原生库
for i, name in ipairs(loader.listSo()) do
    log(i, name)
end

loader.close()

-- 场景1: 插件放脚本目录，直接按函数名调用
local lib = LuaEngine.loadLib('libmyplugin.so')
log(lib.name, lib.count)             -- 插件名 / 函数个数
print(lib.add(1, 2))                 -- 调用 C/C++ 函数
print(lib.hello('古龙'))              -- 字符串参数/返回值
print(lib:call('add', 3, 4))         -- 等价写法（函数名是保留字时用这个）

-- 场景2: 查看插件注册了哪些函数
for i, name in ipairs(lib.functions) do
    log(i, name)
end

-- 场景3: 复杂的表数据用 JSON 字符串传
local info = lib.parse('{"x":1,"y":2}')
log(info)

lib.close()                          -- 卸载插件（脚本结束时自动可省略）

-- JNI 标准写法（.so + Java 包装类）：
-- 1) 载入原生库
LuaEngine.loadSo('libmyplugin.so')

-- 2) 载入声明了 native 方法的 Java 类
local NativeLib = import('com.myplugin.NativeLib')
print(NativeLib.add(1, 2))           -- 调用 native 静态方法
local obj = NativeLib()
print(obj.version())

local headers = {}
headers['User-Agent'] = 'Mozilla/5.0 (Linux; Android 13)'

local ret = LuaEngine.httpGet('https://www.baidu.com', headers)
log('长度: ' .. #ret)

-- 也可以 POST JSON（服务器返回 JSON 时用 json 解析）
local body = {device = 'gulong', ver = 1}
local resp = LuaEngine.httpPost('https://example.com/api', body)

-- 用字符串类名创建（适合类名来自配置的场景）
local clsName = 'java.util.ArrayList'
local list = LuaEngine.newInstance(clsName)
list.add('a')
log(list.size())

-- 用类对象创建
local File = import('java.io.File')
local f = LuaEngine.newInstance(File, '/sdcard/a.txt')
log(f.exists())

-- 取类对象（类不存在返回 nil，不会报错）
local C = LuaEngine.classOf('android.os.Build')
log(C.MODEL, C.VERSION.SDK_INT)      -- 静态字段

// ===== myplugin.cpp =====
#include "gulong_plugin.h"
#include <string.h>
#include <stdlib.h>

static int l_add(void* ctx, int argc, const GulongValue* argv, GulongValue* result) {
    long long a = gulong_arg_int(argv, argc, 0, 0);
    long long b = gulong_arg_int(argv, argc, 1, 0);
    gulong_result_int(result, a + b);
    return 1;   // 1=有返回值, 0=返回 nil
}

static int l_hello(void* ctx, int argc, const GulongValue* argv, GulongValue* result) {
    const char* who = gulong_arg_string(argv, argc, 0, "world");
    // 返回值字符串要长期有效：这里用 static 缓冲
    static char buf[256];
    snprintf(buf, sizeof(buf), "hello, %s!", who);
    gulong_result_string(result, buf);
    return 1;
}

static int l_calc(void* ctx, int argc, const GulongValue* argv, GulongValue* result) {
    double x = gulong_arg_double(argv, argc, 0, 0);
    gulong_result_double(result, x * 3.14159);
    return 1;
}

GULONG_EXPORT int gulong_plugin_init(GulongPluginHost* host) {
    if (host->api_version != GULONG_PLUGIN_API_VERSION) return 1;
    host->add_function(host->ctx, "add",   l_add,   "两数相加", 2, 2);
    host->add_function(host->ctx, "hello", l_hello, "打招呼",   0, 1);
    host->add_function(host->ctx, "calc",  l_calc,  "乘圆周率", 1, 1);
    host->log(host->ctx, "myplugin loaded");
    return 0;   // 0=成功
}

GULONG_EXPORT const char* gulong_plugin_name(void) { return "myplugin"; }
GULONG_EXPORT const char* gulong_plugin_version(void) { return "1.0.0"; }

// ===== Android.mk（放到插件工程 jni/ 目录） =====
// LOCAL_PATH := $(call my-dir)
// include $(CLEAR_VARS)
// LOCAL_MODULE    := myplugin
// LOCAL_SRC_FILES := myplugin.cpp
// LOCAL_CPP_FEATURES := exceptions
// LOCAL_LDLIBS    := -llog
// include $(BUILD_SHARED_LIBRARY)

// ===== 或 CMakeLists.txt =====
// add_library(myplugin SHARED myplugin.cpp)
// target_link_libraries(myplugin log)

// ===== 编译（NDK r25 示例） =====
// cd 插件工程/jni && ndk-build
// 产物: ../libs/arm64-v8a/libmyplugin.so  -> 复制到脚本目录

-- ===== Lua 调用 =====
local lib = LuaEngine.loadLib('libmyplugin.so')
print(lib.add(1, 2))          -- 3
print(lib.hello('古龙精灵'))   -- hello, 古龙精灵!
print(lib.calc(2))            -- 6.28318
print(lib.name, lib.version)  -- myplugin / 1.0.0

-- 用不到的写法：内置的 lib.count 是函数个数
for i, fn in ipairs(lib.functions) do log(fn) end

-- ===== 推荐用法（简写） =====
-- 1) 默认包直接可用，不必 import
log(Math.max(1, 5))                     -- 5
log(tostring(java.util.Date()))          -- 当前时间

-- 2) 需要其它包先整包导入
import('android.hardware.*')
local SensorManager = import('android.hardware.SensorManager')
local ctx = LuaEngine.getContext()
local sm = ctx.getSystemService(Context.SENSOR_SERVICE)
log(tostring(sm))

-- 3) 回调：Lua 函数当接口用
local Thread = import('java.lang.Thread')
local t = Thread(Runnable(function()
    log('子线程执行中')
    -- 注意：不要在这里直接操作界面
end))
t.start()
t.join()

-- 4) 错误处理：用 pcall 包住扩展调用
local ok, err = pcall(function()
    return import('no.such.Class')
end)
if not ok then log('导入失败: ' .. tostring(err)) end