421 lines
14 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/**
* ADB 真机调试(类热更新):
* 1. 列出所有已连接设备,可选择目标设备(多台时交互选择,单台自动选中)
* 2. 进程常驻,监听源码变更
* 3. 变更后自动:build:app → 离线打包(gradle 增量) → adb install -r → 启动应用
*
* 用法:
* npm run dev:adb # 自动选唯一设备
* npm run dev:adb -- --no-launch # 重装后不自动启动应用
* npm run dev:adb -- --adb=adb路径 # 自定义 adb 路径
* npm run dev:adb -- --prod-api # 不注入开发地址,产出与发布包一致的生产环境包
* npm run dev:adb -- --api=http://192.168.1.10:6060 # 指定接口地址
*
* 接口地址(重要):build:app 是 Vite 生产构建,env.js 默认会固定指向生产域名
* (见 env.js 的 PROD_API_BASE)。本脚本默认把 .env.local 里的 VITE_API_BASE_URL
* 通过 VITE_API_BASE_OVERRIDE 注入编译,避免真机调试打到生产库;
* 该变量不写入任何 .env 文件,因此不会影响正式发布包。
*
* 变更监听范围:
* src/(uni-app 前端资源)
* android-offline/HBuilder-Integrate-AS/simpleDemo/src/(原生工程:Manifest/Java/res)
*/
const { spawnSync, spawn } = require('child_process')
const fs = require('fs')
const path = require('path')
const readline = require('readline')
const ROOT = path.resolve(__dirname, '..')
// ---------- adb 路径探测(PATH 里没有时从 SDK 目录找) ----------
function detectAdb() {
const arg = process.argv.find((a) => a.startsWith('--adb='))
if (arg) {
return arg.slice('--adb='.length)
}
if (process.env.ADB) {
return process.env.ADB
}
const candidates = []
const home = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT || ''
if (home) {
candidates.push(path.join(home, 'platform-tools', process.platform === 'win32' ? 'adb.exe' : 'adb'))
}
if (process.env.LOCALAPPDATA) {
candidates.push(path.join(process.env.LOCALAPPDATA, 'Android', 'Sdk', 'platform-tools', 'adb.exe'))
}
candidates.push(process.platform === 'win32' ? 'adb.exe' : 'adb')
for (const c of candidates) {
try {
const res = spawnSync(c, ['version'], { encoding: 'utf-8' })
if (res.status === 0 && /Android Debug Bridge/.test(res.stdout || '')) {
return c
}
} catch (e) {
// 继续
}
}
return 'adb'
}
const ADB = detectAdb()
const NO_LAUNCH = process.argv.includes('--no-launch')
// 监听范围与扩展名
// 注意:不要监听 simpleDemo/src/main/assets(构建注入产物)、res(prepare 会覆盖图标/启动图)、build 目录,否则构建自触发死循环
const WATCH_ROOTS = [
{ dir: path.join(ROOT, 'src'), recursive: true },
{
dir: path.join(ROOT, 'android-offline', 'HBuilder-Integrate-AS', 'simpleDemo', 'src', 'main', 'java'),
recursive: true,
},
{
// 只监听直接文件(AndroidManifest.xml),不递归:assets 是 prepare 注入产物
dir: path.join(ROOT, 'android-offline', 'HBuilder-Integrate-AS', 'simpleDemo', 'src', 'main'),
recursive: false,
},
]
const WATCH_EXTS = new Set([
'.vue', '.js', '.ts', '.json', '.scss', '.css', '.cjs', '.ps1', '.xml', '.java', '.png', '.jpg', '.jpeg', '.md',
])
// ---------- 接口环境(真机调试选地址)----------
/** 读取 .env.local 里指定键的值(文件不存在/未配置时返回空) */
function readEnvLocal(key) {
try {
const text = fs.readFileSync(path.join(ROOT, '.env.local'), 'utf-8')
for (const line of text.split(/\r?\n/)) {
const matched = line.match(/^\s*([A-Za-z0-9_]+)\s*=\s*(.*)$/)
if (matched && matched[1] === key) {
return matched[2].trim().replace(/^["']|["']$/g, '')
}
}
} catch (e) {
// 忽略:文件缺失视为未配置
}
return ''
}
/** 解析本次真机包的接口地址(返回空字符串 = 不注入,沿用构建默认即生产域名) */
function resolveApiTarget() {
if (process.argv.includes('--prod-api')) {
return { base: '', note: '--prod-api 指定,与发布包一致' }
}
const argApi = process.argv.find((a) => a.startsWith('--api='))
if (argApi) {
return { base: argApi.slice('--api='.length), note: '命令行 --api 指定' }
}
const dev = readEnvLocal('VITE_API_BASE_URL')
if (dev) {
return { base: dev, note: '.env.local 的 VITE_API_BASE_URL' }
}
return { base: '', note: '未配置 .env.local,沿用构建默认(生产域名)' }
}
const API_TARGET = resolveApiTarget()
const BUILD_ENV = API_TARGET.base ? { VITE_API_BASE_OVERRIDE: API_TARGET.base } : {}
const log = (msg) => console.log(`[dev-adb] ${msg}`)
// 启动即声明本次真机包的接口地址(长驻 watch 中每次构建还会再打一次)
log(`接口地址 = ${API_TARGET.base || 'https://qimen.wms.gztbyc.com(生产)'} 〔${API_TARGET.note}〕`)
const run = (cmd, args, opts = {}) => {
// Windows 下通过 shell 执行,自动解析 npm.cmd / 全路径 exe
const res = spawnSync(cmd, args, {
cwd: opts.cwd || ROOT,
stdio: 'inherit',
env: { ...process.env, ...(opts.env || {}) },
shell: process.platform === 'win32',
})
if (res.error) {
console.error(`[dev-adb] spawn 失败 ${cmd}: ${res.error.message}`)
return false
}
return res.status === 0
}
// ---------- 1. 列出并解析设备 ----------
function listDevices() {
const res = spawnSync(ADB, ['devices', '-l'], { encoding: 'utf-8' })
const out = res.stdout || ''
log(`adb devices 输出:\n${out.trim()}`)
const lines = out.split(/\r?\n/)
const devices = []
for (const line of lines) {
const m = line.trim().match(/^(\S+)\s+device\b(.*)$/)
if (m) {
devices.push({ serial: m[1], desc: m[2].trim() })
}
}
return devices
}
function ask(question) {
const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
return new Promise((resolve) => {
rl.question(question, (answer) => {
rl.close()
resolve(String(answer || '').trim())
})
})
}
async function pickDevice(devices) {
if (devices.length === 0) {
console.error('[dev-adb] 未检测到任何已连接设备,请检查 USB 连接/ADB 授权后重试')
process.exit(1)
}
if (devices.length === 1) {
log(`唯一设备,自动选中: ${devices[0].serial} (${devices[0].desc})`)
return devices[0]
}
devices.forEach((d, i) => console.log(` [${i + 1}] ${d.serial} ${d.desc}`))
const answer = await ask(`请选择设备序号 [1-${devices.length}],默认 1: `)
const idx = answer ? Number(answer) - 1 : 0
if (!Number.isInteger(idx) || idx < 0 || idx >= devices.length) {
console.error(`[dev-adb] 无效序号: ${answer}`)
process.exit(1)
}
return devices[idx]
}
// ---------- 2. 构建 → 打包 → 安装 → 启动 ----------
let logcatProc = null
// 真机 console 实时打印:logcat 只跟随 UniConsole(逻辑层) 与 UniViewConsole(视图层 renderjs)
function startLogcat(serial) {
if (logcatProc) {
return
}
spawnSync(ADB, ['-s', serial, 'logcat', '-c'], { stdio: 'ignore' })
logcatProc = spawn(ADB, ['-s', serial, 'logcat', '-v', 'time', 'UniConsole:V', 'UniViewConsole:V', '*:S'], {
stdio: ['ignore', 'pipe', 'inherit'],
})
let buf = ''
logcatProc.stdout.setEncoding('utf-8')
logcatProc.stdout.on('data', (chunk) => {
buf += chunk
let idx
while ((idx = buf.indexOf('\n')) >= 0) {
const line = buf.slice(0, idx)
buf = buf.slice(idx + 1)
const trimmed = line.trim()
if (!trimmed) {
continue
}
const isErr = trimmed.includes(' W/') || trimmed.includes(' E/')
console.log(isErr ? `\x1b[31m[真机] ${trimmed}\x1b[0m` : `\x1b[36m[真机] ${trimmed}\x1b[0m`)
}
})
logcatProc.on('exit', () => {
logcatProc = null
// adb 重连/设备重启后自动恢复跟随
setTimeout(() => startLogcat(serial), 3000)
})
log('真机 console 实时打印已开启(UniConsole/UniViewConsole)')
}
function clearLogcat(serial) {
spawnSync(ADB, ['-s', serial, 'logcat', '-c'], { stdio: 'ignore' })
}
function findApk() {
// 优先按 package.json version 精确匹配
try {
const pkg = JSON.parse(fs.readFileSync(path.join(ROOT, 'package.json'), 'utf-8'))
const exact = path.join(ROOT, 'release', 'android', `wms-worker-station_v${pkg.version}_release.apk`)
if (fs.existsSync(exact)) {
return exact
}
} catch (e) {
// 忽略
}
// 兜底:目录里最新的 apk
const dir = path.join(ROOT, 'release', 'android')
if (!fs.existsSync(dir)) {
return null
}
const apks = fs.readdirSync(dir).filter((f) => f.endsWith('.apk')).map((f) => ({
name: f,
mtime: fs.statSync(path.join(dir, f)).mtimeMs,
}))
if (apks.length === 0) {
return null
}
apks.sort((a, b) => b.mtime - a.mtime)
return path.join(dir, apks[0].name)
}
let building = false
let pending = false
let lastChangeAt = 0
let buildFinishedAt = 0
async function buildAndInstall(serial, trigger) {
const t0 = Date.now()
log(`开始构建(触发: ${trigger})`)
log(
`接口地址 = ${API_TARGET.base || 'https://qimen.wms.gztbyc.com(生产)'} 〔${API_TARGET.note}〕`
)
// 1. uni-app 编译 App 资源(注入开发地址,避免真机调试打到生产库)
if (!run('npm', ['run', 'build:app'], { env: BUILD_ENV })) {
log('✗ build:app 失败,跳过安装')
return false
}
// 2. 离线打包(prepare + gradle 增量 + 复制 APK),跳过发布上传
// 用 android:pack:raw 直接打包,避免重复编译(本脚本已在上面跑 build:app)
if (!run('npm', ['run', 'android:pack:raw', '--', '-NoUpload'])) {
log('✗ android:pack:raw 失败,跳过安装')
return false
}
// 3. 定位 APK
const apk = findApk()
if (!apk) {
log('✗ 未找到 APK 产物')
return false
}
log(`APK: ${path.relative(ROOT, apk)}`)
// 4. 安装(失败重试 2 次,设备忙时常见)
for (let i = 0; i < 3; i++) {
const res = spawnSync(ADB, ['-s', serial, 'install', '-r', apk], { stdio: 'inherit' })
if (res.status === 0) {
break
}
if (i === 2) {
log('✗ adb install 失败(已重试 3 次)')
return false
}
log(`安装失败,2 秒后重试 (${i + 1}/2)`)
await new Promise((r) => setTimeout(r, 2000))
}
// 5. 启动应用(Android 7 用 monkey 拉起 launcher 入口最稳)
if (!NO_LAUNCH) {
clearLogcat(serial)
spawnSync(ADB, ['-s', serial, 'shell', 'am', 'force-stop', 'com.gztbyc.sandan'], { stdio: 'ignore' })
spawnSync(ADB, ['-s', serial, 'shell', 'monkey', '-p', 'com.gztbyc.sandan', '-c', 'android.intent.category.LAUNCHER', '1'], { stdio: 'ignore' })
log('已启动应用')
}
log(`✓ 完成,耗时 ${((Date.now() - t0) / 1000).toFixed(1)}s`)
return true
}
async function triggerBuild(serial, trigger) {
if (building) {
pending = true
return
}
building = true
try {
await buildAndInstall(serial, trigger)
} finally {
building = false
buildFinishedAt = Date.now()
if (pending) {
pending = false
log('构建期间有新变更,继续构建...')
triggerBuild(serial, 'pending')
}
}
}
// ---------- 3. 目录监听(Windows 兼容:watch 每个子目录) ----------
function collectWatchDirs() {
const dirs = new Set()
for (const root of WATCH_ROOTS) {
if (!fs.existsSync(root.dir)) {
log(`警告: 监听目录不存在: ${root.dir}`)
continue
}
dirs.add(root.dir)
if (!root.recursive) {
continue
}
const walk = (dir) => {
let entries = []
try {
entries = fs.readdirSync(dir, { withFileTypes: true })
} catch (e) {
return
}
for (const e of entries) {
if (e.isDirectory()) {
const full = path.join(dir, e.name)
if (e.name === 'node_modules' || e.name === '.git' || e.name === 'build' || e.name === '.gradle') {
continue
}
dirs.add(full)
walk(full)
}
}
}
walk(root.dir)
}
return [...dirs]
}
function watchDirs(serial) {
const watched = new Set()
const attach = (dir) => {
if (watched.has(dir)) {
return
}
watched.add(dir)
try {
const watcher = fs.watch(dir, (eventType, filename) => {
if (!filename) {
return
}
// 构建期间自身写入产物(图标/启动图覆盖等)的变更直接忽略,防止自触发循环
if (building || Date.now() - buildFinishedAt < 3000) {
return
}
const ext = path.extname(filename).toLowerCase()
if (!WATCH_EXTS.has(ext)) {
return
}
const now = Date.now()
if (now - lastChangeAt < 150) {
// 一次保存可能触发多次事件,靠防抖合并
}
lastChangeAt = now
clearTimeout(watchDirs._debounce)
watchDirs._debounce = setTimeout(() => {
triggerBuild(serial, `${dir}/${filename}`.slice(ROOT.length + 1))
}, 800)
})
watcher.on('error', () => {
// 目录可能被删除重建,稍后重新收集
})
} catch (e) {
// 忽略
}
}
for (const dir of collectWatchDirs()) {
attach(dir)
}
// 目录结构变化(新增/删除目录)时重新收集
setInterval(() => {
for (const dir of collectWatchDirs()) {
attach(dir)
}
}, 10000)
log(`正在监听 ${watched.size} 个目录,保存文件后自动构建重装...`)
}
// ---------- 主流程 ----------
async function main() {
log(`ADB: ${ADB}`)
const devices = listDevices()
const target = await pickDevice(devices)
log(`目标设备: ${target.serial}`)
startLogcat(target.serial)
watchDirs(target.serial)
log('首次启动构建...')
triggerBuild(target.serial, 'initial')
}
main().catch((err) => {
console.error('[dev-adb] 异常:', err)
process.exit(1)
})