音乐控制/解密

This commit is contained in:
LFeng committed 2026-09-28 00:21:12 +08:00
1 parent 9e6d73e191
commit ff1d5cd517
41 files changed
+10827 -4

No files matched your search

+667
View File
@@ -0,0 +1,667 @@
# 音乐模块 · 本地音乐解密规划(Music Decrypt Plan)
> 状态:**P0 + P1a + P1c 已实施并完成真机端到端验证**(2026-09-27:网易云解密 + QQ音乐离线解密 + 文件夹批量 + musicex 在线取密钥,用真实 192kHz/24bit `.mflac` 样本跑通全链路;Rust 单测 204 项全库通过)
> 定位:音乐模块的「本地解密」子能力,不是独立模块——挂靠 `music` 模块新增「解密」页签,Rust 侧新增 `music/decrypt/` 子模块;`ncm` 与 `qmc` 均为纯 Rust 离线引擎,QQ 按「内嵌 ekey 离线 → musicex 在线取密钥」分层(Frida 降为 P2 兜底)
> 日期:2026-09-27(同日修订:QQ 分层重排、ncm 算法细节补全)
> 关联文档:`AI_DEV_GUIDE.md`(模块注册 / IPC 范式——注意 specta 绑定见 `lib.rs` 的 `export_bindings()`)、`MUSIC_REMOTE_PLAN.md`(规划文档范式)
> 参考项目与**许可分档**:
> - `taurusxin/ncmdump`(<https://github.com/taurusxin/ncmdump>,**MIT**)——§3.1 全部算法细节的对照物,**可逐行对照**。
> - `QQKWKG-TriMusicDecrypt`(QKKDecrypt,<https://github.com/Acooldog/QQKWKG-TriMusicDecrypt>,**GPLv3**)——只取平台矩阵与坑清单。
> - `ownlight6/qmc-decoder`(<https://github.com/ownlight6/qmc-decoder>,**GPLv3**)——只取 QMC/musicex/ekey 的**格式与协议知识**(<https://github.com/ownlight6/qmc-decoder/blob/main/MGG_DECRYPTION_FLOW.md>)。
> - GPLv3 两仓:**只读文档与行为,严禁抄代码**。
---
## 0. 结论先行
1. **范围收敛到两平台**(本轮显式指定):网易云 `.ncm` + QQ音乐 QMC 系列。酷狗/酷我明确出栈,不进任何分期。
2. **两条技术路线,全部纯 Rust,零新增运行时依赖**:
- ncm → **Rust 原生**(`aes 0.8` / `cbc 0.1` / `base64 0.22` 已在依赖;`ecb` crate 不在依赖树,ECB 手写 16 字节块循环,零新增 crate)。
- QQ → **Rust 原生三层路由**(详见 §3.2):① 尾部内嵌 ekey 的文件纯离线可解;② musicex 文件读本机凭据调 `GetEVkey` API;③ 前两层都不成立才用 Frida 注入兜底。
- **本节原有的「Frida 主链」判断已作废**:它把「需要客户端在跑」与「需要 Frida 注入」绑成了一件事。实际只有第③层需要注入,而前两层覆盖绝大多数真实文件。改分层后**不再需要便携 Python、不再需要 `pip install frida`、不再受杀软与 mangled 符号版本漂移影响**。
3. **UI 是音乐模块第 4 个页签「解密」**:`useModuleTabs` 加一项 + `DecryptPanel.vue` + 独立轻量 store,命令与事件挂进现有 music 命令族,完全照抄下载任务的「先回 taskId、进度走事件」范式。
4. **许可边界分三档**:`ncmdump` 是 MIT,**可逐行对照**;QKKDecrypt 与 `qmc-decoder` 是 GPLv3 + FFmpeg GPL,**只沉淀格式/协议知识与坑清单,实现逐行重写**。
5. **工作量**:P0(网易云 + 页签全链路)约 **2 个工作日**;P1a(QQ 离线 + API,纯 Rust)约 **2~3 个工作日**;P1b(Frida 兜底,按需)另计。
```mermaid
flowchart LR
subgraph FE["前端 · 解密页签"]
A["DecryptPanel.vue<br/>文件选择 / 任务列表 / 状态卡"]
S["decryptStore.ts<br/>任务状态 + 事件监听"]
end
subgraph R["Rust · music/decrypt/"]
C["commands.rs<br/>run / cancel"]
N["ncm.rs<br/>网易云离线引擎"]
Q["qq.rs<br/>QMC 三层路由(P1)"]
end
subgraph QQS["QQ 三层(P1)"]
L1["① 尾部内嵌 ekey<br/>纯离线"]
L2["② musicex → 本机凭据<br/>GetEVkey API"]
L3["③ Frida 兜底<br/>(P1b,按需)"]
end
O["savedir/decrypted/"]
A --> S --> C
C --> N --> O
C --> Q --> L1 --> O
Q --> L2 --> O
Q -.-> L3 -.-> O
Q -.->|"music-decrypt-event"| S
N -.-> S
```
---
## 1. 需求解构
| 用户原话 | 解构 | 落点 |
|---|---|---|
| 在音乐模块添加解密 Tabs | 音乐模块第 4 个页签 | §5.2 |
| 解密各平台的加密格式 | 收敛为 QQ音乐 + 网易云(本轮显式指定) | §3 |
| 最小路径实现 | 砍掉:转码、元数据回填、封面提取、拖拽、酷狗酷我、并发调优、历史持久化 | §7 P2 清单 |
| 可参考 QKKDecrypt | 对齐思路与坑,不搬 GPLv3 代码 | §3.3 |
---
## 2. 现状勘察(2026-09-27 从仓库实际读取)
### 2.1 已具备的基建(直接复用)
| 能力 | 现有实现 | 复用方式 |
|---|---|---|
| Tab 体系 | `useModuleTabs`(`MusicModule.vue:78`,alwaysVisible 模式,标题栏浮动切换器自动接管) | 加 `{ value: 'decrypt', label: '解密' }` 一项 |
| 任务 + 事件范式 | `music_download` / `music-download-event`(`commands.rs:187`、`constants.rs:107`) | 解密照抄:先回 taskId,进度推事件 |
| 便携 Python + pip 镜像 | `runtime.rs`(清华源 `PIP_INDEX_URL`,`mod.rs:77`) | QQ sidecar 的 frida 安装、Python 就绪检查 |
| 加密依赖 | `Cargo.toml` 已有 `aes = "0.8"`、`cbc = "0.1"`、`base64 = "0.22"` | ncm 的 AES-128-ECB 手写循环,零新增依赖 |
| specta 绑定 | `lib.rs export_bindings()` 两处 `collect_commands!` | 新命令两处同步登记(`lib.rs:300` 注释明确要求) |
| 文件选择对话框 | `@tauri-apps/plugin-dialog`(`MusicModule.vue:4` 已 import) | 页签内直接用,不加 Rust 命令 |
| 输出目录 | 默认 `savedir`(设置页「本地下载目录」) | 解密默认输出 `savedir/decrypted/` |
| 播放引擎 | symphonia(`Cargo.toml:115`) | 解出的 flac/mp3/ogg 可直接进曲库试听 |
### 2.2 关键缺口(需新增)
| 缺口 | 说明 |
|---|---|
| ncm 解密实现 | 纯算法,约 200 行 + 单测 |
| QQ 运行期 sidecar | Frida 注入 + `EncAndDesMediaFile` 调用序列,按参考思路重写 |
| 解密任务 store | 下载任务在 `musicStore`;解密需独立轻量 store(页签切换会卸载组件,监听器必须挂 store) |
| frida 依赖安装 | `pip install frida`(wheel 带原生扩展,走现有镜像),需一条安装命令 + 进度事件 |
---
## 3. 技术选型
### 3.1 网易云 `.ncm`:Rust 原生离线
**为什么不进 Python**:
- ncm 是纯文件级算法,不需要任何进程配合;塞进 Python 等于把 200 行算法绑上「必须先装运行时」的前置。
- 便携 Python 是按需安装(musicdl 才触发),解密不应被它卡住——Rust 路线开箱即用。
- Rust 侧可直接 `cargo test`,对照样本文件做回归。
**算法要点**(对照 MIT 协议的 `ncmdump`(`src/ncmcrypt.cpp`)逐条独立重写。下面每一条都是**会写错的地方**,不是梗概):
**① 容器结构**
```
0x00 magic 8B "CTENFDAM"(即 43 54 45 4E 46 44 41 4D)
0x08 2B 0x02 0x00 → 跳过
0x0A key_len 4B LE
0x0E key_data key_len B (XOR 0x64 → AES-128-ECB → 得 RC4 密钥盒种子)
... meta_len 4B LE
... meta_data meta_len B (XOR 0x63 → 去 22B 前缀 → base64 → AES-128-ECB → 去 6B 前缀 → JSON)
... 5B 跳过(CRC32 4B + 图片版本 1B)
... cover_len 4B LE
... img_len 4B LE
... img_data img_len B (内嵌封面:PNG 或 JPEG)
... 跳 cover_len - img_len
... audio 剩余全部 (改性 RC4)
```
**② 两个 XOR 常量不同**(原文档误合并成一个 `0x64`)
| 段 | XOR 常量 | 加密方式 | 解密后处理 |
|---|---|---|---|
| key 段 | `0x64` | AES-128-ECB | **跳过前 17 字节**(`neteasecloudmusic`),其余即 RC4 密钥盒种子 |
| meta 段 | `0x63` | AES-128-ECB(先 base64 解码) | 跳过前 6 字节(`music:`),其余为 JSON |
**③ AES-128-ECB 解密**:**key 段与 meta 段用两个不同的 16 字节密钥**——`sCoreKey` = ASCII `neteasecloudmusi`(即 17 字节前缀 `neteasecloudmusic\0` 的前 16 字节)、`sModifyKey` = ASCII `#14ljk_!\]&0U<'(`。**收尾不是"去前缀",而是 PKCS#7 风格 padding**:逐 16 字节块解密,最后一字节即 padding 长度(`> 16` 时视作 0),去掉 padding 后再手动跳前缀。
> 易错点:**「AES 密钥」与「要剥掉的前缀」是两个东西**。`neteasecloudmusic` 既是被剥的 17 字节前缀(含结尾 NUL),其前 16 字节又是 key 段的 AES 密钥;meta 段则两者都不同。混用不报错、只会全解错(实现里分别命名为 `CORE_KEY` / `CORE_AES_KEY` / `MODIFY_KEY`)。
**④ meta 段的两层前缀**:原始数据前 22 字节是字面量 `163 key(Don't modify):`,**先剥掉它**,再对余下部分 base64 解码,才喂给 AES。
**⑤ 音频段是「改性 RC4」**
- 密钥盒用参考实现的 KSA:`swap = keybox[i]`;`c = (swap + last_byte + key[key_offset]) & 0xff`,`key_offset` 触 keyLen 归零循环取 key,`keybox[i] = keybox[c]`、`keybox[c] = swap`、`last_byte = c`。**照抄即可,但注意 `last_byte` 在模 256 下是恒等变形(结果与标准 RC4 逐字节相同),它既不是"关键差异",也不能作为验证手段**——见 §6.25。
- 明文按 `0x8000` 字节一块循环,块内 `j = (i + 1) & 0xff`,`plain[i] = cipher[i] ^ keybox[(keybox[(keybox[j] + j) & 0xff] + keybox[j]) & 0xff]`。块之间不重置密钥盒、也不额外跳字节——`i` 是块内下标。
- **块边界必须由"读满一块"确定**(`read_full`),不能用 `Read::read` 的短读结果,否则相位错位、中途变噪声(§6.24)。
- **不存在"每 0x8000 字节后跳过 5 字节间隔"**(原文档此条有误)。`0x8000` 是块大小,`5` 是 §① 里跳过的 CRC32 + 图片版本。
**⑥ 输出扩展名由音频首帧魔数决定,不是 meta 的 `format` 字段**(原文档此条说反了):首个解密块以 `ID3`(`0x49 0x44 0x33`)开头 → `.mp3`,否则 → `.flac`。meta 的 `format` 只用于另一件事——**判断该不该回填标签/封面时的格式分支**。
**⑦ 顺手可得的元数据**:meta JSON 含 `musicName` / `artist`(二维数组,取每项第 0 个元素并用 `/` 连接)/ `album` / `bitrate` / `duration`,且封面字节已在上面的 `img_data` 里读出。**P0 已实现封面单独落盘**(`<歌名>.cover.png|jpg`,按魔数定扩展名);**写进音频标签**仍留 P2——那需要 `lofty` 且要按 mp3/flac/m4a 分派容器,属于「增强」而非「能播」。
**⑧ 失败处理**:魔数不符 / `key_len <= 0` / 块不足 16 字节 → 返回可读错误(`Err(String)`),**per-file 失败不 panic、不中断整批**。
### 3.2 QQ音乐:Rust 原生三层路由(**本节已重写**)
**原判断作废的理由**:原文把「需要 QQ 客户端在跑」与「需要 Frida 注入」绑成了一件事。二者其实独立——ekey(解密密钥)有三种存储形态,只有第三种才需要注入。前两层覆盖真实曲库的绝大多数文件,且都是纯 Rust。
**QMC 加密本体**(与 ncm 同构:字节流密码 + 可选密钥):
| 方案 | 密钥来源 | 适用 |
|---|---|---|
| QMC1 | 固定种子,**无需密钥** | 旧版 `.qmc0` / `.qmc3` / `.qmcflac` / `.qmcogg` |
| QMC2 | ekey(base64 + TC-TEA 加密),密钥 ≤300B 走 Map XOR,>300B 走改性 RC4 | `.mgg` / `.mflac` 全系 |
**ekey 的三种存储形态 → 三层路由**:
| 层 | 形态 | 需要客户端? | 实现方式 |
|---|---|---|---|
| **①** | **尾部内嵌 ekey**:QTag 格式(ekey + 歌曲 ID + `QTag` 魔术)或 V1 格式(文件末尾 4 字节为 key 长度,key 在其前) | ❌ 不需要 | **纯 Rust 离线**,从文件尾直接提取 |
| **②** | **musicex 尾部**(QQ 客户端 ≥ 19.57 / Win 22.x):尾部 192B 只存 song_id + media_mid + filename,**ekey 不落盘** | ✅ 需运行且已登录 | **纯 Rust**:读凭据 → 调 API 取 ekey |
| **③** | 客户端内部导出(方案原文所选) | ✅ | Python sidecar + Frida attach `QQMusicCommon.dll` |
**第②层的完整链路**(全部可在 Rust 内完成,`windows-sys` 只差一个 feature):
1. 尾部检测:读末 8 字节,为 `"musicex\0"` 即 musicex;再向前读 `footer_size + 8` 解析完整 footer(`0x00` song_id u32LE、`0x0C` media_mid UTF-16LE 60B、`0x48` filename UTF-16LE 68B、`0xC0` footer_size、`0xC8` magic)。
2. 取 `uin`:读 `%APPDATA%\Tencent\QQMusic\QQMusicServiceConfig.ini` 的 `[Account] Uin`(明文 INI)。
3. 取 `authst`:**`authst` 在 Windows 上不落盘**,仅在运行中的 `QQMusic.exe` 进程内存里。用 `CreateToolhelp32Snapshot` + `Process32FirstW/NextW` 定位进程 → `OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ)` → `VirtualQueryEx` 遍历可读区(只需 `MEM_COMMIT`,跳过 `MEM_MAPPED`)→ `ReadProcessMemory` 按 1MB 分块 → 搜 `"authst":"` 取其后 Base64URL 串。实测约 0.5 秒。
4. 调 API:`POST https://u.y.qq.com/cgi-bin/musicu.fcg`,`req_1.module = "music.vkey.GetEVkey"`、`method = "CgiGetEVkey"`;`param.filename` **必须带 `.mgg`/`.mflac` 后缀**、`param.songtype` **必须为 1**(否则返回 `104005`)、`param.platform = "27"`(Windows)。响应取 `req_1.data.midurlinfo[0].ekey`。
> 三处易错点:`MEMORY_BASIC_INFORMATION` 在 Win10 1803+ 有 2 字节 `PartitionId` 插在 `AllocationProtect` 与 `RegionSize` 之间,**漏掉会导致 `state` 读成 `protect`、所有内存区被跳过**;`filename` 不带扩展名返回空 ekey;`authst` 有效期约 22.3 小时会过期。
**前置检查与降级出口**(UI 状态卡据此渲染):QQ 未运行或未登录 → 提示"请启动并登录 QQ 音乐后重试";层①②均失败的文件才落到③;Frida 不可用时报可读错误并给排除指引,**不自动拉起 QQ 客户端**。
**③(P1b,按需)的形态**若将来要做:`qq_decrypt.py` 走 `include_str!` 内置(与 `bridge.rs:17` 的 `BRIDGE_SCRIPT` 同范式),一次进程 attach 一批文件,stdout JSON-Lines 回报进度;导出符号是 mangled name(`?Open@EncAndDesMediaFile@@…`),**按子串 `EncAndDesMediaFile` 模糊匹配,严禁硬编码地址或 RVA**。
**输出扩展名**(不能按输入扩展名机械映射):`.qmc0`→`.mp3`、`.qmc3`→`.mp3`、`.qmc2`→`.ogg`、`.qmcogg`→`.ogg`、`.qmcflac`→`.flac`、`.mgg`/`.mgg0`/`.mgg1`/`.mggl`→`.ogg`、`.mflac`/`.mflac0`/`.mflach`→`.flac`(均以首帧魔数兜底校验)。**`.mmp4` 的产物容器(m4a 还是 mp4)尚未独立证实,实施 P1 时必须用真机样本确认后再定**。
### 3.3 许可边界(必须遵守,三档口径)
- **MIT(可逐行对照)**:`taurusxin/ncmdump`(网易云 ncm 算法本体)。可直接对照 `src/ncmcrypt.cpp` 实现,仅需保留版权声明。
- **GPLv3(只读文档与行为,严禁抄代码)**:`QQKWKG-TriMusicDecrypt`(+ FFmpeg GPL)、`ownlight6/qmc-decoder`。**整段搬代码 = 给本仓库引入 GPL 传染。** 允许的是:阅读其调用序列、常量、格式与协议说明后**独立重写**——本文档 §3.1 / §3.2 沉淀的正是这类非代码知识。
- **合规口径**(UI 底部放一行):仅处理用户本人拥有合法访问权限的本地文件,不用于批量分发或规避付费授权。
---
## 4. 接口契约
### 4.1 Tauri 命令
```rust
// 任务
music_decrypt_run(task_id, files?, folder?, root?, out_dir?, in_place?) -> Result<(), String>
music_decrypt_cancel(task_id: String) -> Result<bool, String>
// 预览与状态
music_decrypt_scan(folder: String, root: Option<String>) -> Result<ScanSummary, String>
music_decrypt_qq_status() -> Result<QqOnlineStatus, String> // 只读本机,不发网络请求
```
`QqOnlineStatus` 字段:`{ running, loggedIn, uin, ready, message, steps }`。
**`authst` 不下发到前端**——它只活在后端内存里用于调接口。
- **注册是 3 处,不是 2 处**(实测仓库现状):
1. `music/mod.rs` 的 `pub use commands::{...}` re-export(约 `mod.rs:48`);
2. `lib.rs` 的 `collect_commands![]`(`export_bindings()` 内,`lib.rs:205`);
3. `lib.rs` 的 `generate_handler![]`(`run()` 内,`lib.rs:348`)。
漏第 2 处 = 运行时能调但 `bindings.ts` 缺类型;漏第 1、3 处 = 编译失败或调用失败。
- 前端沿用本模块既有范式(`musicStore.ts` 全用原生 `invoke` + 手写类型,不用 `commands`),故解密 store 同样用 `invoke`。
### 4.2 事件 `music-decrypt-event`(登记进 `constants.rs` 音乐分组)
```typescript
type MusicDecryptEvent = // 注意:只有 tag 是 kebab-case,**字段名仍是 snake_case**
| { type: 'start'; task_id: string; total: number }
| { type: 'file'; task_id: string; index: number; name: string;
status: 'ok' | 'error' | 'unsupported';
message: string | null; // 失败原因,或成功时的备注(平台 / 密钥形态 / 元数据摘要)
output: string | null; // 主产物
cover: string | null } // 单独落盘的封面(网易云带内嵌封面时才有)
| { type: 'progress'; task_id: string; done: number; total: number;
bytes_done: number; bytes_total: number; name: string }
| { type: 'finished'; task_id: string; ok: number; failed: number; cancelled: number }
```
> **字段名是 snake_case 而非 camelCase**:`DecryptEvent` 上只有 `#[serde(tag = "type", rename_all = "kebab-case")]`
> 作用在 tag 上,变体字段名原样输出。前端 `decryptStore.ts` 的 `RawEvent` 必须照此声明
> ——两边不一致时不会编译报错,只会表现为「任务建好了但进度永不动」。
> Rust 侧有 `event_json_contract` 单测把形状钉死(§6.23)。
>
> 结果态没有 `already`:P0 不做「已解密过则跳过」(同一文件重解会产出 `_1` 后缀的新文件),
> 语义比"猜哪份产物属于哪次输入"更可预测。
> 原先的 `deps-install` 事件随 `music_decrypt_install_deps` 一起取消——三层路由后不再需要 `pip install frida`。
> 注意前端 `musicStore.ts:419` 是**硬编码事件名字符串**、并未引用前端常量表,故解密 store 同样硬编码,仅 Rust 侧登记常量。
### 4.3 文件识别(用户不选平台)
按扩展名路由,魔数校验兜底:
| 扩展名 | 路线 |
|---|---|
| `.ncm` | 网易云离线引擎(按内容魔数识别,不依赖后缀) |
| `.mgg` / `.mgg0` / `.mgg1` / `.mggl` / `.mflac` / `.mflac0` / `.mflach` / `.mmp4` / `.qmc0` / `.qmc2` / `.qmc3` / `.qmcflac` / `.qmcogg` | QQ 引擎(按尾部形态决定是否联网) |
| 其他 | 散选时保留为 `unsupported`;文件夹扫描时直接跳过 |
> 后缀矩阵原文档只列了 3 个,会**静默漏掉用户曲库里的常见文件**,故过滤列表与路由表**一次写全**。
> 实际判定以**内容**为准(§4.5),后缀只用于文件对话框的过滤器。
### 4.3.1 QQ 音乐:是否需要登录?
这是使用者最常问的一点,所以结论放在前面:
| 文件来源 | 扩展名 | 需要 QQ 音乐登录? |
|---|---|---|
| QQ 客户端 **≤ 19.51** 下载 | `.qmc0` `.qmc3` `.qmcflac` `.qmcogg` | **不需要** |
| QQ 客户端较旧版本下载(QTag / V1 尾部) | `.mgg` `.mflac` | **不需要** |
| QQ 客户端 **≥ 19.57** 下载(musicex 尾部) | `.mgg` `.mflac` `.mmp4` | **需要**:客户端运行 + 已登录 |
| 网易云(任何版本) | `.ncm` | **不需要** |
**为什么新版必须登录**:从 19.57 起,QQ 音乐不再把解密密钥(ekey)写进文件,
只在文件末尾留 192 字节元数据;客户端自己也是在播放/下载时拿本机登录态
(`uin` + `authst`)向服务器实时换取密钥。第三方要解开同一个文件,只能复刻这一步。
**这里的实现方式**:只读本机凭据(INI 里的 `uin` + 运行中 `QQMusic.exe` 内存里的 `authst`),
再调官方 `music.vkey.GetEVkey` 接口取密钥——**不注入进程、不改写文件、不做任何反检测**。
**操作步骤**(与 UI 状态卡里的文案一致):
1. 在电脑上启动 QQ 音乐客户端(Windows 版)。
2. 用它登录你的账号,并**保持客户端开着**(`authst` 只存在于运行期内存)。
3. 回到「解密」页点「重新检测」,状态变为「已就绪」即可解密 musicex 文件。
4. 若提示未取到登录令牌:先在客户端里**播放任意一首歌**触发一次网络请求,再重新检测。
5. 仍失败则试过**以管理员身份运行**本应用(读其他进程内存可能需要更高权限)。
6. 登录令牌约 **22.3 小时**过期;过期后重新检测即可,无需重装。
**UI 呈现**:状态卡显示三态(未运行 / 未登录 / 已就绪)+ QQ 号 + 「重新检测」按钮;
未就绪时折叠区里就是上面这 6 条步骤。上方那句"旧版文件与 `.ncm` 本来就不需要登录"
也会一并显示,避免用户误以为自己必须登录才能用这个功能。
### 4.4 输出路径规则
- **就地模式(`in_place = true`,文件夹批量的默认)**:产物与源文件**同目录同名**,
仅按格式改扩展名(`Pop/a.mflac` → `Pop/a.flac`)。符合"就地解出来"的直觉,
也天然不会与其他目录的同名文件冲突。此时 `out_dir` 不参与写盘。
- **指定输出目录(`in_place = false`)**:默认根目录 `savedir/decrypted/`,
并**按 `root` 还原相对目录结构**(`Pop/2026/b.ncm` → `out/Pop/2026/b.flac`)。
散选文件没有相对目录,平铺到根目录。
- **同名去重**:即使还原了目录结构,同一目录内仍可能撞名(如 `.mgg` 与 `.mgg1` 同基名)。
规则:优先用原名,已存在(磁盘上或本批内已占位)则追加 `_1` / `_2`…
- **输入输出相交保护**:非就地模式下,若某输入文件已位于输出目录内则剔除,
避免"解出来再解"无限膨胀;全被剔除时报错并提示可改用「就地解密」。
- 扩展名以**音频首帧魔数**决定(ncm 见 §3.1⑥,QMC 见 §3.2 末),不信任输入扩展名;
魔数认不出时才回退到输入后缀映射。
### 4.5 文件夹批量
命令参数的关系:
| 参数 | 含义 |
|---|---|
| `folder` | **文件夹批量入口**:Rust 侧递归扫描该目录 |
| `root` | 计算相对路径的基准(决定输出目录里还原哪几层) |
| `files` | 散选文件列表(`folder` 为空时使用) |
| `in_place` | 就地解密(默认 `true`,见 §4.4) |
| `music_decrypt_scan` | 只扫描不解密,返回 `{ total, ncm, qmc }` 供 UI 预览 |
**平台判定按内容,不按后缀**(`scan::route`):
1. 读 8 字节魔数,命中 `CTENFDAM` → 网易云;
2. 否则读尾部判 QMC 形态:后缀在 QMC 家族里 → QQ音乐;
3. 后缀不认识时,只有**明确**的尾部形态(QTag / V1 / musicex)才认领——
否则任何末尾凑巧不是 `QTag` 的文件都会被判成"QMC1",噪声太大。
理由:同一曲库里 `.ncm` / `.mflac` / `.qmcflac` / `.mgg` 混放是常态,且 QQ 还有
`.mgg0` / `.mflac0` 等变体,靠后缀枚举必然漏。代价是**认不出的文件会被跳过**,
所以扫描数可能少于用户预期——因此 UI 先调 `music_decrypt_scan` 显示
"找到 N 个 · 网易云 x · QQ音乐 y",让用户在开跑前就能判断是否符合预期。
---
## 5. 架构与模块设计
### 5.1 Rust 侧 `src-tauri/src/music/decrypt/`(已实施的实际结构)
```
decrypt/
mod.rs // 任务表(Mutex<HashMap<taskId, 取消标志>>)、工作线程 + 节流事件转发、事件契约
common.rs // 两引擎公共件:DecryptError、魔数定格式、同名去重、读满一块
ncm.rs // 网易云离线引擎(AES-ECB + RC4 变体 + meta/封面)
qmc.rs // QQ:QMC1 静态密钥 / QMC2 Map / QMC2 RC4 / tc_tea / 尾部形态 + 流密码
qq_footer.rs // musicex 尾部解析(纯,可单测)
qq_credentials.rs // 凭据:INI 解析(纯)+ 进程内存取 authst(平台胶水)
qq_memscan.rs // Windows 专用:ToolHelp 枚举进程 + VirtualQueryEx/ReadProcessMemory(只读)
qq_ekey.rs // GetEVkey 请求组装与响应解析(纯,可单测)
qq_online.rs // 编排:musicex → 凭据 → 取密钥 → 解密;probe_status()
scan.rs // 文件夹递归扫描 + 内容优先的平台路由
commands.rs // run / cancel / scan / qq_status(四条命令)
```
平台判定与密钥来源的**分工**:`scan.rs` 只决定"这文件归哪个引擎";
`qmc.rs` 决定"密钥从哪来"(内嵌 / 静态);只有尾部是 musicex 时,
调度层才把 `KeyRequired` 交给 `qq_online.rs` 转在线路径——这样离线路径保持零网络依赖。
`mod.rs` 挂到 `music/mod.rs` 的子模块列表;事件常量加进 `constants.rs` 音乐分组。
### 5.2 前端
```
src/modules/music/components/DecryptPanel.vue // 页签内容
src/stores/decryptStore.ts // 任务列表 + 事件监听(照 musicUploadStore 范式)
MusicModule.vue // tabs 加一项 + <TabsContent value="decrypt">
index.ts // searchItems 加「音乐解密」(tab: 'decrypt')
```
**P0 / P1a / P1c UI 形态**(已实施):
- 顶部操作行:**选择文件夹** | 选择文件(dialog 多选,按 §4.3 全后缀过滤)| **就地解密开关** | 取消 / 清空记录
- **QQ 音乐在线解密状态卡**:状态点(三态)+ 一句话状态 + QQ 号 + **重新检测** + 折叠的**操作步骤**;
未就绪时折叠区里就是 §4.3.1 那 6 条,并附一句"旧版文件与 `.ncm` 本来就不需要登录"
- 输出目录行:就地模式下置灰并显示"与源文件同目录"
- **文件夹扫描预览条**:显示"找到 N 个 · 网易云 x · QQ音乐 y" + 开始解密按钮
- 中部任务表:任务头(文件夹路径 / 进度条 / `bytes_done/bytes_total` / 打开产物目录)|
文件行(文件名 | 平台徽标 | 状态徽章 | 打开产物目录 | 打开封面 | 备注或失败原因)
- 空态用 `StateBlock variant="empty"`;进度条结构恒定(完成后保留满格,不整块消失)
- 底部一行合规说明
### 5.3 数据流
与下载链路同构:前端 → `music_decrypt_run` → Rust 建 taskId 即回 → 后台执行 → `music-decrypt-event` → `decryptStore` 更新 → 列表刷新。页签切换组件卸载不影响任务(监听在 store)。
---
## 6. 关键实现细节与已知的坑
**ncm**(编号对应 §3.1 的条目号)
1. `aes 0.8` 只有块原语、`ecb` crate 不在依赖树:ECB 手写 16 字节块循环(`cipher::BlockDecrypt::decrypt_block`)。**不要**为此引入 `ecb` crate。
2. **两段 XOR 常量不同**(`0x64` key / `0x63` meta)。照抄成同一个常量 = 必然失败。
3. **PKCS#7 风格 padding**:AES-ECB 收尾取最后一字节为 padding 长度(`> 16` 视作 0),不是“去前缀”。
4. **改性 RC4 KSA 的 `last_byte` 累加**(照抄参考实现即可,但别误解它):
式子 `c = (swap + last_byte + key[key_offset]) & 0xff` 在模 256 下**恰好化简为标准 RC4**,
实测两者密钥盒逐字节相同(256/256)。因此它**不是**"与标准 RC4 的关键差异",
也不能靠与标准 RC4 比对来验证实现——验证只能靠固定向量(见 §6.25)。
`key_offset` 触 keyLen 归零循环取 key 这一点照抄。
5. **音频块之间不跳字节**,`0x8000` 只是块大小;`i` 是块内下标。原文档的"每 0x8000 跳过 5 字节"是错的(那 5 字节在 §① 的头部里,且已单独处理)。**但块边界必须由"读满一块"确定**,不能用 `Read::read` 的短读结果(见 §6.24)。
6. **输出扩展名看音频首帧魔数**(`ID3` → `.mp3`,否则 `.flac`),不看 meta 的 `format`。
实现比这条更宽一点:还识别 `fLaC` / `OggS` / `RIFF..WAVE` / `ftyp` / `wvpk`,
给 P1 的 QQ 产物复用(ncmdump 的兜底同为 flac)。
7. meta 段是**两层前缀**:先剥 22 字节 `163 key(Don't modify):`,再 base64,再 AES,再剥 6 字节 `music:`。
8. **流式处理**:`0x8000` 块逐块读→解→写,禁止整文件读入内存(`.mmp4` 可能很大)。大文件下需按已处理字节数推 `progress`。
9. **单测不依赖真实样本**:真实 FLAC 最小样本进不了仓库。改为对**中间产物**断言——AES-ECB 往返、KSA 密钥盒已知值、padding 剥离、魔数→扩展名判定、以及"自造一个合法 ncm 容器(用同一套算法正向构造)再解回来"的往返测试。真机样本走手动自测。
10. 魔数/解析失败走 per-file `Err`,**不 panic、不中断整批**。
**QQ(P1)**
11. 第①层(QTag / V1)**完全离线**,不要因为"QQ 文件"就先去连客户端——先用尾部分支判形态再决定要不要读凭据。
12. 第②层的 `authst` **只在 `QQMusic.exe` 运行期内存里**,不落盘;`uin` 在 `QQMusicServiceConfig.ini` 可明文读。`MEMORY_BASIC_INFORMATION` 的 2 字节 `PartitionId`(Win10 1803+)**必须包含**,否则 `state` 会读成 `protect`、所有内存区被跳过。
13. API 三处必须:`filename` 带 `.mgg`/`.mflac` 后缀、`songtype = 1`、`module = music.vkey.GetEVkey`(不是 `GetVkey`)。否则 `104005` 或 ekey 为空。
14. `authst` 约 22.3 小时过期:失败文案要给"重新登录 QQ 音乐"的出口,而不是只报网络错误。
15. 第③层(Frida):必须**先启动 QQ 音乐**再 attach,`QQMusicCommon.dll` 打开主界面即加载;导出符号是 mangled name,**按子串 `EncAndDesMediaFile` 模糊匹配,严禁硬编码地址或 RVA**;被杀软拦截只给排除指引,**不做反检测动作**;批量时客户端 UI 可能短暂卡顿,属预期。
16. `path_sensitive_mflac` 变体(同名文件不同目录内容不同)P1 不处理:报错带全路径,遇到再迭代。
17. `.mmp4` 产物容器未证实,P1 先用真机样本确认再定(见 §3.2 末)。
**工程**
18. 新命令登记 **3 处**:`music/mod.rs` re-export、`lib.rs` 的 `collect_commands![]`、`lib.rs` 的 `generate_handler![]`(见 §4.1)。
19. `music-decrypt-event` 常量进 `constants.rs` 音乐分组;前端沿用硬编码字符串(与 `musicStore.ts:419` 一致)。
20. 解密 store 必须独立于组件生命周期:Tabs 非 active 会卸载内容,事件监听挂 store 不挂组件。
21. **输出同名去重 + 输入输出相交保护**(见 §4.4)——原文档缺失,不做会静默覆盖用户文件。
22. 三层路由后**不再需要便携 Python 与 frida**,`music_decrypt_install_deps` 命令取消;QQ 未登录的错误出口走状态卡提示。
**实施中新增确认的坑(2026-09-27 实测)**
23. **事件字段名是 snake_case**(不是 camelCase)。`#[serde(tag = ..., rename_all = "kebab-case")]`
只作用于 tag,变体字段名原样输出。前后端不一致时**不报错**,只表现为进度不动。
Rust 侧 `event_json_contract` 单测钉死 JSON 形状。
24. **音频块边界必须用"读满一块"而非 `Read::read` 的返回值**。`BufReader::read` 会短读,
块边界一漂移,解密式里的「块内偏移 `i`」就与加密侧错位,表现为**文件从中间某处起全是噪声**
(实测首个坏字节落在 32418,仍在第一大块内),前半段却完全正常,极难排查。
已加 `read_full()` 专门处理。
25. **`last_byte` 累加在模 256 下是恒等变形**:`c = swap + last_byte + key` 与标准 RC4 的
`j += s[i] + key` 结果**逐字节相同**(已实测 256/256 一致)。所以:
- 不能靠"与标准 RC4 比对"来验证密钥盒实现;
- 也**不要**以为它是"改性 RC4 的关键差异"而据此改写(本计划早期的 §6.4 表述即由此误导)。
真正的验证手段是**固定向量**(`key_box_matches_reference_vectors` /
`keystream_matches_reference_vector`)。
26. **`MODIFY_KEY` 是 16 字节而非 17**(`aes::Aes128` 的密钥长度就是 16);
`CORE_KEY` 的 17 字节是**解密后要剥掉的前缀**,与 AES 密钥不是同一个东西
(AES 密钥是它的前 16 字节)。两者混用不会编译报错,只会全解错。
27. **合成容器单测的 key 段必须带 `neteasecloudmusic` 前缀**——否则解密端剥前缀后拿到错种子。
这个坑一度被"单循环 KSA"的错误实现掩盖(两边同时错、往返仍然自洽)。
**P1a(QQ 离线)实施中新增确认的坑**
28. **QMC2 Map 密码的 `scramble` 必须用 `wrapping_shl/shr`**(对移位量取模),
不能写成 `u8::rotate_left/rotate_right`——后者会在内部再取一次模,结果**不同**。
被 Apache 参考实现的原向量抓到(若不比对向量,会产出"能跑但全错"的解密)。
29. **tc_tea 不是 TEA-ECB,而是 TEA 变体 + 自定义 CBC**:块与密钥字都是**大端**、
16 轮(非 32)、单轮是 `((v<<4)+k1) ^ (sum+v) ^ ((v>>5)+k2)`,
且明文前置 `1+pad+2` 字节头、尾部 7 字节 0 自校验。照 TEA-ECB 写会解出**部分可读的乱码**
(表现极具迷惑性:能看到明文碎片)。尾部 0 校验正是"密钥对不对"的权威判据。
30. **V1 尾部判定不能只看长度**:任意加密数据末尾都可能凑出 `0<n<=0x400`,
只按长度判会把普通 QMC1 文件误判成 V1 并砍掉一大截音频(实测 32871 字节 → 4096)。
必须追加"前面那一段像不像 base64 ekey"的校验。
31. **`sniff_tail` 的 `audio_len` 必须换算成绝对长度**:它只读了尾部 probe,
`detect_tail` 给出的是**相对 probe 起点**的偏移;QMC1(无尾部)必须回落到**整个文件大小**。
另外**不要在两个地方各写一遍尾部探测**——当初 `decrypt_file` 自己复制了一遍,
修了 `sniff_tail` 却没修它,症状是"探测结果对、实际产物只有 4KB"。
32. **QMC1 的掩码分支是 `pos > 0x7FFF`(严格大于)**,不是 `>=`;写成 `>=` 会在回绕点差一字节。
**P1c(musicex 在线)实施中新增确认的点**
33. **`MEMORY_BASIC_INFORMATION` 的 `PartitionId`(Win10 1803+)**:直接沿用
`windows-sys` 的结构体即可,但**自己手写 `#[repr(C)]` 时千万别漏**——漏了会让
`RegionSize`/`State`/`Protect` 全部读错偏移,`VirtualQueryEx` 返回的 `State`
读成 `Protect`(如 `0x04` 而非 `0x1000`),于是所有内存区被跳过、永远扫不到 token。
34. **`getEVkey` 的三个"必须"**:`filename` 带扩展名、`songtype=1`、
`module=music.vkey.GetEVkey`(不是 `GetVkey`)。任一写错都只是"拿不到 ekey",
不会报错——所以请求体用纯函数组装并单测锁死(`qq_ekey::build_evkey_request`)。
35. **`authst` 会过期(约 22.3 小时)**:失败文案必须给"重新登录 / 重新检测"的出口,
否则用户会以为是网络问题。响应里的 `expiration` 已带进产物备注。
36. **单元测试不要真的发网络请求**:本机一旦登录成功,测试就会去连 QQ 服务器,
导致测试变慢变脆。改为验证"请求体能正确构造"+"`#!Qk` 头守卫"+"尾部能被解析出
`media_mid`/`filename`"三段——真实响应留给真机端到端。
37. **musicex 音频段要校验 `#!Qk` 头**:尾部像 musicex 不代表内容真是 QMC2 密文;
没有这道守卫会把任意文件"解"成垃圾却报告成功。
**真机端到端验证后修正(2026-09-27)**
38. **`#!Qk` 不是 QMC2 密文的通用魔术**(推翻第 37 条的做法):真机 musicex 样本
(Avicii - Heaven,197MB `.mflac`)的密文头是 **`51 74 03 75`**,按"必须以 `#!Qk`
开头"写的守卫会把**完全合法的文件误拒**。
正确做法是**用解密结果判定密钥是否正确**:用取到的密钥解出前 16 字节,
看是否是已知音频魔术(`fLaC` / `OggS` / `ID3` / `ftyp`…)——密钥错时它是随机噪声,
几乎不可能凑巧命中;命中即说明密钥对、文件也对。
这也是"内容优先"原则的又一次应用:**不要用猜测的密文特征做判据,要用能验证的结果。**
39. **文档给的 musicex 字段偏移在真样本上是对的**:`0x0C` media_mid(60B UTF-16LE)、
`0x48` filename(68B UTF-16LE)、`0xC0` footer_size、`0xC8` magic 全部命中,
尾部实测 192 字节、padding 区有 13 个非零字节(所以不能假设 padding 全 0)。
40. **真机样本的规模提醒**:`.mflac` 可达 197MB / 192kHz / 24bit。
`qq_online` 目前把音频段整段读入内存再解密(探针与生产路径都是),
在这个量级下可用,但如果将来遇到多 G 的文件,应改成分块解密 + 流式写盘
(`qmc` 的流密码本身已支持任意偏移)。
---
## 7. 分阶段计划
### P0 — 网易云 + 解密页签全链路(约 2 天)**✅ 已实施(2026-09-27)**
- [x] `useModuleTabs` + `TabsContent` 接「解密」页签;`index.ts` 搜索条目
- [x] `decrypt/ncm.rs`:§3.1 全部要点 + 单测(**18 项通过**)
- [x] `decrypt/mod.rs` + `commands.rs`:run / cancel + 事件发射;**三处**登记;`constants.rs` 事件常量
- [x] `decryptStore.ts` + `DecryptPanel.vue`:选文件 → 批量任务 → 进度 → 打开输出目录
- [x] 输出同名去重 + 输入输出相交保护(§4.4)
- [x] 封面单独落盘(`<歌名>.cover.png|jpg`)——标签回填仍留 P2(`lofty` 需按容器分派)
- [ ] **自测:真实 `.ncm` 样本解出**(需人工用真机样本验证;仓库内样本有版权且体积大,故算法靠 §6.9 的中间产物单测 + 合成容器往返覆盖)
- **验收**:页签选 10 个 ncm 全部解出、失败有原因、切页签不丢任务、播放器直接可播
**已交付文件**:
| 文件 | 内容 |
|---|---|
| `src-tauri/src/music/decrypt/ncm.rs` | 网易云离线引擎(容器解析 / AES-ECB / 密钥盒 / 流式解密 / 魔数定格式 / 封面 / 同名去重)+ 单测 |
| `src-tauri/src/music/decrypt/mod.rs` | 任务表、工作线程 + 节流事件转发、`DecryptEvent` 契约(含 JSON 形状单测) |
| `src-tauri/src/music/decrypt/commands.rs` | `music_decrypt_run` / `music_decrypt_cancel` + 输出目录解析与相交保护 |
| `src/stores/decryptStore.ts` | 任务状态 + 事件监听(挂 store,不随组件卸载) |
| `src/modules/music/components/DecryptPanel.vue` | 页签 UI |
| `music/mod.rs` · `lib.rs` · `constants.rs` | 子模块挂载、`MusicManager.decrypt` 字段、三处命令登记、事件常量 |
### P1a — QQ 离线解密 + 文件夹批量(**✅ 已实施,纯 Rust,无 Python/frida**)
- [x] `decrypt/qmc.rs`:QMC1 静态密钥表 / QMC2 Map 密码 / QMC2 RC4 变体 / tc_tea(TEA 变体 + 自定义 CBC)
- [x] 第①层:QTag 与 V1 尾部 ekey 提取 → **离线解密**
- [x] `decrypt/scan.rs`:递归扫描 + 内容优先的平台路由 + 保留相对目录结构
- [x] **文件夹批量**:`folder` / `root` / `in_place` 三个参数 + `music_decrypt_scan` 预览命令
- [x] `decrypt/common.rs`:两引擎统一的错误类型、魔数定格式、同名去重、读满一块
- [x] 单测 **56 项**(模块合计 174 项全库通过),含参考实现的原始测试向量
- [ ] 第②层 musicex + `GetEVkey` API(**未实施**,见 P1c)
- [ ] 真实 `.mflac/.mgg/.qmcflac` 样本自测(需人工;仓库内不放版权样本)
**已交付文件(P1a 增量)**:
| 文件 | 内容 |
|---|---|
| `src-tauri/src/music/decrypt/qmc.rs` | QMC 全套离线算法 + 尾部形态判定 |
| `src-tauri/src/music/decrypt/scan.rs` | 文件夹递归扫描与平台路由 |
| `src-tauri/src/music/decrypt/common.rs` | 两引擎公共件 |
**算法来源(全部宽松许可,均有原始向量锁行为)**:
| 部分 | 来源 | 许可 |
|---|---|---|
| QMC1 静态密钥表 + 掩码规则 | `jixunmoe/qmc-decode` | MIT |
| QMC2 密钥派生 / Map / RC4 / 尾部形态 | `bczhc/qmc-dec`(`qmc2-crypto`) | Apache-2.0 |
| tc_tea | `tc_tea` crate | MIT/Apache-2.0 |
### P1b — Frida 兜底(按需,不计入本轮)
- [ ] `qq_decrypt.py`(`include_str!`):attach → `EncAndDesMediaFile` 调用序列 → 批量 → JSON-Lines 进度
- [ ] `decrypt/qq_frida.rs`:前置检查、spawn、逐行读转发事件
- **触发条件**:仅当 §3.2 的第③层文件在真实用户场景中被确认存在且前两层无法覆盖时才做
### P1c — musicex 联网取 ekey(**✅ 已实施**)
- [x] `qq_footer.rs`:musicex 尾部解析(song_id / media_mid / filename)
- [x] `qq_credentials.rs`:读 `%APPDATA%\Tencent\QQMusic\QQMusicServiceConfig.ini` 的 `uin` + 扫进程内存取 `authst`
- [x] `qq_memscan.rs`(Windows):`CreateToolhelp32Snapshot` + `OpenProcess` + `VirtualQueryEx` + `ReadProcessMemory`(**只读**)
- [x] `qq_ekey.rs`:`GetEVkey` 请求组装与响应解析(`filename` 带扩展名 / `songtype=1` / `platform="27"`)
- [x] `qq_online.rs`:编排 + `probe_status()` 在线能力探测
- [x] `music_decrypt_qq_status` 命令 + UI 状态卡(含**逐步操作说明**)
- [x] `windows-sys` 增开 `Win32_System_Diagnostics_ToolHelp` 与 `..._Debug`
- [x] **本机实测**:`probe_status()` 返回 `running=true logged_in=true uin=1154027699 ready=true` —— 内存扫描确实取到了 `authst`
- [x] **端到端已用真机样本跑通**(2026-09-27,见下)
#### 真机端到端验证记录(首个 musicex 样本)
样本:`C:\Users\Administrator\Music\Heaven - Avicii_EM.mflac`(197,104,516 字节,
尾部 `musicex\0`,`song_id=233102682`,`media_mid=003iTvi44A6RMs`,
`filename=AIM0002ELI6a1wXJDo.mflac`)
| 环节 | 实测结果 |
|---|---|
| 尾部解析 | song_id / quality1=2 / quality2=11 / media_mid / filename 全部正确 |
| 凭据 | 返回 `running=true logged_in=true uin=1154027699 ready=true` |
| `GetEVkey` | **成功**,拿到 704 字符 ekey;`expiration=80400`(22.3 小时,与文档一致) |
| ekey → 密钥 | 解密出 **512 字节**原始密钥 → 命中 **RC4 变体**(>300 字节)分支 |
| 音频段 | 197,104,324 字节(= 文件大小 − 192 字节尾部,完全吻合) |
| 解密结果 | 首帧 `66 4c 61 43` = **`fLaC`** ✅ |
| 产物校验(`lofty`) | **277.261 秒 · 192000 Hz · 24 bit · 2 声道 · 5686 kbps** —— 192kHz/24bit Hi-Res 无损 |
**验证方式**:`examples/decrypt_musicex_probe.rs` 走真实链路(读内存凭据 → 真实
HTTP 请求 → 解密),再用 `examples/verify_audio.rs` 交给项目同款解析器确认产物合法。
两个 example 都保留,供后续 QQ 改协议时快速定位。
**这次验证推翻了一个错误假设**:样本的密文头是 `51 74 03 75`,**不是**文档里提到的
`#!Qk`。原先按"密文必须以 `#!Qk` 开头"写的守卫会把完全合法的文件误拒——已改为
**用解密结果判定**(解出的前 16 字节是否为已知音频魔术),见 §6.38。
**凭据可用性已知限制**:
| 维度 | 情况 |
|---|---|
| `uin` 来源 | INI 明文,稳定 |
| `authst` 来源 | 仅运行期内存;**QQ 音乐必须开着且已登录** |
| 有效期 | 约 22.3 小时(响应 `expiration` 字段,已带进产物备注) |
| 权限 | 读他人进程内存可能需管理员;失败文案已提示 |
| 是否注入 | **否**,纯只读——这是它与 Frida 兜底的本质区别 |
### P2 — 按需增强(不进本轮)
- **ID3 / FLAC / MP4 标签回填**(用 `lofty`,按容器分派;meta JSON 已在解密时解析出来)
- 解密完成 →「加入本地曲库」/ 上传飞牛(复用 `musicUploadStore`)
- 拖拽文件进页签、解密历史持久化
- 酷狗 / 酷我(除非再次明确要求)
- QQ 变体适配(path_sensitive_mflac)
> **变更**:原计划把「封面提取 / ID3 标签回填」一起从 P2 提前到 P0。**实际只提前了封面提取**——
> 封面字节在解析容器时顺手就读出来了,落盘是十几行,且不做就"能播但难用"。
> 标签回填仍留 P2:它需要 `lofty` 且要按 mp3/flac/m4a 分派容器,属于增强而非可用性门槛。
---
## 8. 风险与开放问题
| 风险 | 影响 | 对策 |
|---|---|---|
| QQ 改 musicex 尾部/API 协议 | 第②层失效 | 协议字段集中在 `qq_footer` / `qq_ekey` 两处;错误文案带原始响应码;关注 qmc-decoder issue |
| `authst` 提取被安全软件拦截 | 第②层失效 | **只读**内存、不注入;失败给"以管理员身份运行"出口 |
| **musicex 端到端** | ~~真实响应字段可能与文档不符~~ **已验证通过**(真机 197MB 样本,产物为合法 192kHz/24bit FLAC) | 保留 `examples/decrypt_musicex_probe.rs` + `verify_audio.rs`,QQ 改协议时可快速定位 |
| `authst` 过期(22.3h) | 第②层短期失效 | 错误文案给"重新登录/重新检测"出口;有效期带进产物备注 |
| QQ 版本升级改 mangled 导出符号 | 仅第③层(Frida)失效 | 子串模糊匹配;第③层不在实施范围,影响面已缩小 |
| 真实样本不足导致算法细节偏差 | 解出错文件 | **已用参考实现的原始测试向量交叉验证**(QMC1 掩码 / Map / RC4 / tc_tea / ekey 端到端) |
| GPLv3 边界被无意破坏 | 许可风险 | 三档口径见 §3.3;QMC 只取 MIT / Apache-2.0 两份来源的**代码与数据** |
| 网易云改 ncm 格式 | 个别文件失败 | per-file error 不中断整批 |
| 同名文件落盘互相覆盖 | **用户文件丢失** | §4.4 同名去重 + 相交保护 |
| 文件夹扫描漏文件(内容认不出) | 用户以为解完了 | UI 先出 `music_decrypt_scan` 预览数量 |
**开放问题**:
1. 解密输出默认就地(文件夹批量)或 `savedir/decrypted/`(散选);独立设置项留 P2。
2. QQ 未运行时是否自动拉起?**离线层与 `.ncm` 完全不需要客户端**;只有 musicex 需要,
当前选择"只提示、不自动拉"(客户端要登录,自动拉起也解决不了登录态)。
3. `.mmp4` 的产物容器(m4a / mp4)待真机样本确认——当前靠首帧 `ftyp` 魔数判定,认不出时按后缀落 `m4a`。
(`.mflac` 已实测确认:产物为 192kHz/24bit 的 `.flac`。)
4. ~~musicex 端到端未验证~~ **已解决**(2026-09-27,真机样本跑通,见 P1c 的验证记录)。
5. `.mflac0` / `.mgg1` 等变体按 QMC2 处理,但**未用真实样本验证**过其尾部形态与 `.mflac` / `.mgg` 一致。
6. 微信登录的 QQ 音乐 (`tmeLoginType=3`):实现上 `authst` 与 QQ 登录通用,
但 `login_type` 目前固定发 `1`(QQ 登录实测可用)——若真机发现微信登录取不到 ekey,需按凭据来源推断。
7. **大文件内存占用**:`qq_online` 目前整段读入内存解密;197MB 实测可用,
但 `.mflac` 可以更大。若遇到多 G 文件,应改流式(`qmc` 的流密码已支持任意偏移)。
---
## 附录 A:参考项目对照(只取思路)
### A.1 QKKDecrypt 实测结论(2026-09-27 深读 `main@938b22d`,来自其源码而非猜测)
**最重要的一条**:该项目 QQ 路径**完全不解析 QMC 加密格式**——它把原始加密文件整包交给 QQ 自己的 DLL 解密,因此不受 static/map cipher 变体影响。**代价是强依赖四项**:QQ 客户端运行 + `QQMusicCommon.dll` 已加载 + **管理员权限**(`cli.py::_require_admin()`,非管理员直接 `return 2` 并打印"已禁止继续使用")+ mangled 名/编译器版本不变。**这四项与它的"回退"一起,正是我们改走 §3.2 分层路由的原因。**
| QKKDecrypt 文件 | 可借鉴 | 不可借鉴 |
|---|---|---|
| `platforms/qq/adapter.py` | `SUPPORTED_SUFFIXES` 仅 `.mflac/.mgg/.mmp4`;前置检查项;ASCII 暂存 |
| `qq/runtime/qqmusic_decrypt.py` | `EncAndDesMediaFile` 的 3 组候选 mangled 名、NativeFunction 全 `thiscall` 签名、调用序(`Memory.alloc(0x28)` → ctor → `allocUtf16String` → `Open(..,1,0)` → `GetSize` → `Read` → dtor) | **硬编码**;整文件读入内存;未校验 `Open`/`Read` 返回值 |
| `qq/runtime/frida_decrypt_gateway.py` | 进程查找用**子串匹配** `"qqmusic"`;**每批次只 attach 一次**并缓存 session | 无 session 重连(QQ 中途重启即失效) |
| `qq/variant_adapter.py` | "路径敏感型 mflac"→**解密前先复制到纯 ASCII 路径**(`pick_safe_tmp_dir`:盘根 `_qqmusic_tmp` → 项目根 → `tempfile.gettempdir()`) | 只实装了这一个变体 |
| `qq/internal_direct.py` / `qq/export_fallback.py` | — | **存在但未接入主流程 = 死代码**,不可当作可用的回退能力承诺 |
| `platforms/netease/adapter.py` | 输出扩展白名单法 | **它没有自研 ncm 算法**——直接 `from ncmdump import NeteaseCloudMusicFile` 委托 PyPI 的 `ncmdump-py`;且 `predicted_extension()` 会**多解密一遍**(性能坑) |
| `Application/decrypt_service.py` | 事件粒度 = **逐文件 `index`/`total`**;`file_finished.result ∈ success/failed/already_decrypted` | 事件种类过多(20+) |
| `cover_art_service.py` | "本地同名图 → 缓存 → 联网"的 local-first 顺序 | **给网易云产物做封面兜底时查的是 QQ 音乐 API** |
| `THIRD_PARTY_LICENSES.md` | 合规口径与风险表述 | 内置 FFmpeg 为 `--enable-gpl --enable-version3` 构建 → 传染面比"仓库 GPLv3"更大 |
**对本文档的两处直接修正**:
1. **"输出扩展名看音频首帧魔数"得到双重印证**——QKKDecrypt 的最终扩展名同样**不取映射表**,而是 `detect_audio_container()` 从实际字节判定(`fLaC`/`OggS`/`RIFF..WAVE`/`ID3`/`0xFF 0xFB|0xF3|0xF2`/偏移 4 处 `ftyp`)。故 §3.2 的输出扩展名表仅作**声明/预期**用,实际以魔数为准。
2. **`.mgg` 解出后它强制归一为 `.m4a`**(`normalize_target_format` 把 `ogg→m4a`)。本项目**不跟**这个行为——`Cargo.toml:112` 已确认 symphonia 默认特性含 `ogg/vorbis`,直接落 `.ogg` 即可播,保持"所见即所得"(§3.1 原口径)。
3. QKKDecrypt 不支持 `.mflac0/.mgg1/.mflac1/.qmc*`——**我们的扩展面比它宽**(§4.3),但格式知识来源是 qmc-decoder 的**文档**(GPLv3,不抄代码)。
### A.2 借鉴到 P0 的一条设计(**最终未采用,附理由**)
QKKDecrypt 的 `file_finished.result` 含 `already_decrypted` 与 `stopped_by_user` 两个态。
**`stopped_by_user` 已采纳**(取消后 `finished.cancelled > 0`,任务落为"已取消")。
**`already_decrypted` 决定不做**:它要判断"某份已存在的产物是否就是本次输入的产物",
在扁平输出目录里只能靠文件名猜,猜错就静默跳过用户的文件——代价大于收益。
P0 改为**永不跳过**:目标名被占用就写 `<名>_1.<ext>`,宁可多一份产物也不丢工作。
(`ncm::unique_output` 同时处理"磁盘上已存在"与"本批次内已占用"两种情况。)
+303
View File
@@ -0,0 +1,303 @@
# 音乐模块 · 手机端连接与控制规划(Music Remote Plan)
> 状态:**规划中**(未开始实施)
> 定位:音乐模块的"手机互联"子能力,不是独立模块——挂靠 `music` 模块,Rust 侧新增 `music/remote/` 子系统
> 日期:2026-09-25
> 关联文档:`AI_DEV_GUIDE.md`(模块注册 / IPC 范式——注意其未涵盖 specta,绑定范例见 `lib.rs` 的 `export_bindings()`)、`TERMINAL_MODULE_PLAN.md`(规划文档范式)
> 对端文档:`F:\AtieProject\LFMusic\PLAN.md`(手机端 LFMusic 的功能与实现规划,协议以本文 §4(协议)/ §5(实现)为准)
---
## 0. 结论先行
四个关键判断,先摆在这里,后文展开论证:
1. **"获取电脑端正在播放的内容(不管是不是 Thing 播的)"必须走 GSMTC**(`GlobalSystemMediaTransportControlsSessionManager`),而不是扩展现有的 `smtc.rs`。`smtc.rs` 以"Thing → 系统"的元数据/进度上报为主(`ISystemMediaTransportControlsInterop::GetForWindow`),并经 `TypedEventHandler` 接收系统按钮回传(双向)——但它只管自己这条会话;要读到**系统里所有应用的媒体会话**(网易云、QQ 音乐、浏览器、Thing 自己……),唯一官方通道是 GSMTC 的全局会话管理器。两者方向相反、互不冲突,`smtc.rs` 原样保留。
2. **控制链路统一走 GSMTC 的 `Try*Async`,Thing 自己不特殊处理**。手机发的播放/暂停/切歌 → Thing 的 GSMTC 调用 → 系统把按钮事件派发给目标会话。Thing 自己因为已在 `smtc.rs` 注册了 SMTC 会话并有按钮事件回传链路(`music-smtc-button` → 前端执行),这条环路是现成的,**对 Thing 自身会话近乎零新增执行代码**(需补的是 cmd-ack 语义与派发时序定义,见 §4.2 / §5.2)。不要为 Thing 自建"直通 AudioEngine"的旁路——多一条路径就多一类不一致(P1 若延迟体感明显再优化)。
3. **局域网服务用 axum(已有依赖)新增 HTTP + WebSocket 双通道,发现用"电脑广播 beacon + 手动扫码"双保险**。axum 已在 `download_engine/server.rs` 和 `feiniu/proxy.rs` 两处落地,范式现成。发现协议不选 mDNS 做 P0 主路径:Android/iOS 的 mDNS 栈碎片化、路由器 AP 隔离下失效、iOS 后台受限;而电脑端周期性 UDP 广播 + 手机被动监听实现最简、权限最友好,配合二维码手动配对兜底已覆盖 99% 场景。mDNS 降级为 P1 增强。
4. **安全按"配对制"设计,不做裸奔**。首次连接用一次性配对码(Thing 弹窗展示,手机扫码/手输),换取长期设备 token;token 两侧持久化(Thing 侧入 keyring,手机侧入系统安全存储),后续连接 WS 握手鉴权,设置页可随时撤销设备。局域网明文 HTTP 在 P0 可接受(风险面:同网段已配对 token 泄露才会被利用),TLS 自签放 P2。
**工作量估算**:P0(系统会话捕获 + LAN 服务 + 发现配对 + 基础遥控)约 6~9 个工作日;P1(mDNS、多会话切换、系统音量、投播)约 5~8 个工作日;P2(TLS、队列投播完善)按需。
---
## 1. 需求解构
用户需求拆成可执行的规格:
| 用户原话 | 解构为 | 落点 |
|---|---|---|
| 「手机端 app 打开后自动连接局域网电脑上的 Thing」 | 电脑端局域网服务(HTTP+WS)+ 自动发现(UDP beacon)+ 配对与鉴权 | §3.2 / §3.3 / §3.4 |
| 「可以获取到电脑端正在播放的内容(不管是 Thing 自己播放的,或是其他应用播放的)」 | GSMTC 全局会话监视:当前活跃会话的元数据、进度、播放状态、封面 | §3.1 / §5.2 |
| 「显示例如歌曲名,歌手,专辑,封面,进度」 | `NowPlaying` 状态模型 + WS 增量推送 + 封面 HTTP 端点 | §4 / §5.2 |
| 「控制等等」 | 播放/暂停/上一首/下一首/seek/停止,走 GSMTC `Try*Async`;音量 P1 | §3.1 / §5.3 |
| (自然延伸,非本次明说) | 投播:手机选歌 → 电脑播放(Thing 曲库播放队列控制) | §7 P2 |
| 「打开后自动连接」的边界 | 首次需用户在电脑设置页点「连接手机」弹出配对码/二维码,5 分钟内完成一次配对;此后已配对设备才自动重连 | §3.4 / 对端文档 §5.1 |
---
## 2. 现状勘察(2026-09-25 从仓库实际读取)
### 2.1 已具备的基建(直接复用)
| 能力 | 现有实现 | 本功能可复用的部分 |
|---|---|---|
| 播放引擎 | `music/audio/engine.rs`:`AudioEngine`(symphonia + cpal/WASAPI 独立线程),`AudioState` 快照 + `music-audio-ended` / `music-audio-error` 事件 | Thing 自身播放状态的事实来源;封面/元数据兜底可直读播放队列 |
| SMTC 上报 | `music/smtc.rs`:`SmtcController`(GetForWindow 全字段上报 + 系统按钮事件 `music-smtc-button` 回传前端) | **零改动保留**;它让 Thing 拥有一条标准 SMTC 会话,GSMTC 控制才能作用到 Thing 自己 |
| HTTP 服务范式 | `download_engine/server.rs`、`feiniu/proxy.rs` 均为 axum + `tokio::net` | 新 LAN 服务照抄此范式(`axum::serve` + tokio) |
| WebSocket | `tokio-tungstenite 0.24` 已在依赖树 | 备选;WS 通道直接用 axum 的 `ws` feature 更统一 |
| 凭据存储 | `secrets.rs`(keyring + Windows 凭据管理器)、`music/secrets.rs` | 设备 token / 配对密钥持久化 |
| 类型绑定 | tauri-specta 自动生成 `src/lib/bindings.ts` | remote 命令与消息类型走 specta,前端零手写类型 |
| 设置持久化 | `MusicManager::load_settings / save_settings`(settings.json + 500ms 缓存) | remote 开关/端口等设置项追加到 `MusicSettings` |
| 日志 | `logger.rs` 统一日志 | remote 全链路日志 |
### 2.2 关键缺口(需新增)
| 缺口 | 现状 | 方案 |
|---|---|---|
| 系统媒体会话读取 | 无。`windows` crate 未开 `Media_Control` feature | 开启 feature,新增 `music/remote/glsmtc.rs`(见 §3.1) |
| 局域网服务 | axum 仅用于本机/代理场景,无对外 LAN 端点 | 新增 `music/remote/server.rs`,监听 `0.0.0.0` |
| 设备发现 | 无 | 新增 `music/remote/discovery.rs`(UDP beacon) |
| 配对与设备管理 | 无 | 新增 `music/remote/pairing.rs` |
| 二维码渲染 | 无 | 前端引入 `qrcode`/`qr-code-styling`(纯前端生成即可) |
---
## 3. 技术选型
### 3.1 系统媒体捕获:GSMTC
Windows 10 1809+ 的 `Windows.Media.Control` 命名空间是**唯一**能枚举/监视/控制系统全部 SMTC 会话的公开 API。凡是有标准系统集成(SMTC)的播放器——网易云、QQ 音乐、foobar2000、浏览器、以及 Thing 自己——都会出现在会话列表里。
Rust 侧路径:`windows` crate(当前 0.52)增加 `"Media_Control"` feature,类型位于 `windows::Media::Control`:
```rust
use windows::Media::Control::{
GlobalSystemMediaTransportControlsSessionManager,
GlobalSystemMediaTransportControlsSession,
};
```
核心 API 清单:
| API | 用途 |
|---|---|
| `SessionManager::RequestAsync()` | 取全局管理器单例(惰性初始化,失败则整个能力降级关闭) |
| `manager.GetSessions()` | 枚举所有会话——**同步**返回 `IVectorView`(0.52 投影无 Async 版本,计划原文 `GetSessionsAsync` 有误,以实测为准) |
| `manager.GetCurrentSession()` | 当前"活跃"会话(系统自动判定:最近操作的会话);**同步**,无会话时 ABI 返回 null → windows-rs 投影为 `Err(E_POINTER)`,按"无会话"分支处理。**实测修正:WinRT 没有 `SetCurrentSessionAsync`**——P1 多会话切换采用 Thing 侧"选中覆盖"(§7),不修改系统判定 |
| `session.SourceAppUserModelId` | 来源应用标识(用于显示"正在播放的应用",也作为会话 key) |
| `session.TryGetMediaPropertiesAsync()` | 元数据:Title / Artist / AlbumTitle / AlbumArtist / **Thumbnail** |
| `session.GetTimelineProperties()` | Position / EndTime / **LastUpdatedTime**(进度推算基准,见 §6.4) |
| `session.GetPlaybackInfo()` | PlaybackStatus / Controls(`IsPlayEnabled` 等能力位)/ PlaybackRate |
| `TryPlayAsync` / `TryPauseAsync` / `TryStopAsync` / `TrySkipNextAsync` / `TrySkipPreviousAsync` | 控制(即手机端全部按钮的实现) |
| `TryChangePlaybackPositionAsync(ticks)` | seek(仅当会话 `IsSeekEnabled`) |
| 事件:`CurrentSessionChanged` / `MediaPropertiesChanged` / `TimelinePropertiesChanged` / `PlaybackInfoChanged` / `SessionsChanged` | 状态变更推送源 |
**线程与套间**(沿用 `smtc.rs` 已验证的范式,但有一处关键差异):
- 初始化(`RequestAsync`)与事件订阅在**主线程**执行(`run_on_main_thread` 抛过去),与 `smtc.rs` 一致。
- **`Try*Async` 的 `.get()` 阻塞等待必须放专用工作线程**,不能在主线程 `.get()`——STA 上阻塞等待 WinRT async 有死锁风险,而 `smtc.rs` 那种"fire-and-forget 更新属性"不涉及等待所以没踩到。设计上:主线程只做"发起",等待统一丢给 `tokio::task::spawn_blocking` 或专用线程。
- 所有 GSMTC 对象是 agile 的,跨线程传引用安全(与 smtc.rs 注释同源结论)。
**失败策略**:与 `smtc.rs` 同哲学——GSMTC 任何一步失败只记日志,不影响播放;GSMTC 初始化失败时整个"远程查看/控制其他应用"能力降级为"仅 Thing 自身"(可从 `AudioEngine.state()` 兜底聚合,见 §5.2)。
### 3.2 局域网服务:axum HTTP + WebSocket
单端口(默认候选 **26124**,被占则 +1 重试至 26139,实际端口写进 beacon 与二维码):
| 端点 | 方法 | 用途 |
|---|---|---|
| `/ws` | GET(Upgrade) | 主通道:鉴权、状态推送(server→client)、控制指令(client→server) |
| `/api/state` | GET | REST 兜底快照(WS 不可用/调试用),Bearer token 鉴权 |
| `/cover/:hash` | GET | 封面字节流(内存缓存,`hash` 由状态推送携带,`?v=` 控制刷新),Bearer token(query 参数 `t=`,`<img>` 标签无法带 header);**访问日志不打印 query**,token 不落日志 |
| `/pair` | POST | 配对:`{ pairingCode, deviceName }` → `{ token, deviceId }` |
WS 承载双向消息(协议见 §4.2);HTTP 承载资源(封面)与低频操作。全部监听 `0.0.0.0`。
**防火墙注意**:首次监听 LAN 端口 Windows 会弹防火墙授权(专用网络勾选即可)。在设置页 remote 开关旁给出说明文案;不做 `netsh` 自动加规则(改系统防火墙属于越权行为,且需要管理员)。
### 3.3 设备发现:UDP beacon(P0 主)+ 扫码兜底(P0)+ mDNS(P1)
| 方案 | 机制 | 判断 |
|---|---|---|
| **UDP beacon(推荐 P0)** | 电脑每 3s 向 `255.255.255.255:26123` 与各网卡定向广播地址发 JSON 包:`{ "service": "thing-music", "deviceId", "name", "port", "protoVer" }`;手机监听 26123 被动收集 | 实现最简(一个 tokio interval + UdpSocket);手机端只需 bind 收包,**Android 免多播权限问题,iOS 不触发 multicast entitlement**(仍会触发本地网络权限弹窗,属正常) |
| 扫码/手输(P0 兜底) | Thing 设置页展示二维码:`thingmusic://connect?ip=…&port=…&code=…`;手机扫码或手输 IP+配对码 | AP 隔离下 beacon 不可达时的最后手段;同时它就是配对入口(见 §3.4) |
| mDNS(P1 增强) | `mdns-sd` crate 注册 `_thingmusic._tcp.local.`,手机 browse | 生态标准、后台发现友好;但依赖各端 mDNS 栈质量,放 P1 不阻塞 |
beacon 里**不含**任何敏感信息(无 token、无配对码),只描述"这里有一个 Thing 音乐服务"。手机端根据 deviceId 去重。
### 3.4 安全与配对
流程(对齐业界遥控 App 的标准做法):
1. 手机端发起配对:beacon 得到 ip:port 后 POST `/pair`,携带 6 位一次性配对码 + 设备名。
2. 配对码由 Thing 侧生成:用户在设置页点击「连接手机」→ 弹窗展示 6 位码 + 二维码(码内含 ip/port/code,扫码即完成 1、2 两步),有效期 5 分钟,一次性。
3. 校验通过 → 生成 32 字节随机 hex 设备 token,返回手机;Thing 侧持久化 `{deviceId, deviceName, token}` 到 keyring(复用 `secrets.rs` 范式),列表落 settings。
4. 后续连接:WS 握手首条消息 `hello { token }`(或 HTTP `Authorization: Bearer`),校验失败 3 次即拉黑该 IP 60s;`/pair` 的配对码校验执行同一限速(防 6 位码爆破,配对响应也只在成功时下发 token)。
5. 设置页设备列表:展示在线/离线、最后连接时间,可撤销(吊销 token)。
P2 增强:自签 TLS(`rcgen` 生成 + `rustls`,二维码里带证书指纹)。P0 明文 HTTP 的风险面评估:同局域网内明文嗅探只能看到 token 之后的媒体元数据;token 本身仅在配对响应中明文传输一次,可接受。
---
## 4. 状态模型与协议设计
### 4.1 `NowPlaying`(核心状态, specta 类型双端共享)
```typescript
interface NowPlaying {
sessionId: string // 会话 key(SourceAppUserModelId;Thing 自身 = "thing.self")
sourceApp: string // 来源应用显示名(AUMID 末段或注册表友好名)
isThing: boolean // 是否 Thing 自身播放(决定封面/元数据兜底来源)
title: string
artist: string
album: string
coverHash: string | null // 封面缓存键;封面从 /cover/:hash 拉
status: 'playing' | 'paused' | 'stopped'
durationSec: number
positionSec: number // 推送时刻的位置
positionUpdatedAtMs: number // 电脑时钟毫秒(源自 TimelineProperties.LastUpdatedTime,见 §6.4);仅供校准,手机端 elapsed 一律以本地收包时刻起算(见 §6.10)
playbackRate: number
canControl: { play: boolean; pause: boolean; next: boolean; prev: boolean; seek: boolean }
deviceId: string // 电脑标识(多电脑预留)
}
```
### 4.2 WS 消息(JSON,`type` 字段区分)
| 方向 | type | 载荷 | 时机 |
|---|---|---|---|
| c→s | `hello` | `{ token, deviceName, protoVer }` | 连接后首条;失败即断开 |
| s→c | `welcome` | `{ deviceId, deviceName, protoVer }` | 鉴权通过 |
| s→c | `state` | `NowPlaying`(全量) | 连接后、以及任何变更(见 §6.3 节流;**由 `cmd` 触发的变更立即推一帧,绕过节流**) |
| c→s | `cmd` | `{ id, action, args? }`,action ∈ `play / pause / toggle / next / prev / stop / seek(posSec)` | 用户操作 |
| s→c | `cmd-ack` | `{ id, ok, error? }` | 回执语义 = **"指令已被接受/派发"**(GSMTC 路径 = Try*Async 完成;前端兜底路径 = 事件已投递),不代表播放状态已切换;UI 轻提示,真实状态以随后的 `state` 为准 |
| c→s | `ping` / s→c `pong` | `{ ts }` | 30s 心跳,双向判活 |
版本策略:`protoVer` 从 1 起,不匹配时 `welcome` 带最新版本号,手机端提示升级。
---
## 5. 架构与模块设计
### 5.1 Rust 侧:`src-tauri/src/music/remote/`
```
src-tauri/src/music/remote/
├── mod.rs # RemoteManager:manage() 进 State;启动/停止服务与 beacon;开关状态
├── server.rs # axum app:路由 /ws /api/state /cover /pair;WS 会话表(fanout 广播)
├── glsmtc.rs # GsmtcMonitor:GSMTC 初始化、事件订阅 → 聚合 NowPlaying → 广播
├── discovery.rs # UdpBeacon:3s 周期广播(255.255.255.255 + 各网卡定向广播)
├── pairing.rs # 配对码生成/校验、设备 token 签发、设备表(keyring + settings)
└── proto.rs # NowPlaying / WS 消息类型(serde + specta,前端 bindings 自动生成)
```
数据流:
```
GSMTC 事件(主线程订阅)──→ GsmtcMonitor 聚合/节流 ──→ Server 广播到全部 WS 客户端
AudioEngine.state()(兜底聚合,isThing 时封面/元数据来源之一)┘
手机 cmd ──→ server.rs ──→ glsmtc.rs(spawn_blocking 调 Try*Async)──→ 系统派发给目标会话
└─ Thing 自身会话:SMTC 按钮 → smtc.rs 既有链路 → 前端 feiniuStore 执行(既有链路,约束见 §5.2)
```
`MusicManager` 增加 `remote: RemoteManager` 字段(或平级 manage,倾向后者,避免 MusicManager 继续膨胀);`lib.rs` 注册 `remote_*` 系列命令:
| 命令 | 用途 |
|---|---|
| `remote_get_config` / `remote_set_enabled` | 开关(MusicSettings 追加 `remote_enabled`、`remote_port`) |
| `remote_status` | 服务状态、端口、在线设备 |
| `remote_start_pairing` | 生成配对码 + 二维码 payload(前端渲染二维码) |
| `remote_cancel_pairing` | 取消 |
| `remote_list_devices` / `remote_revoke_device` | 设备管理 |
### 5.2 双来源聚合规则(GSMTC 为主,AudioEngine 兜底)
- GSMTC 可用:一切以 GSMTC 当前会话为准。Thing 自身播放时它就是一条普通会话(`SourceAppUserModelId` 识别后标 `isThing: true`)。
- GSMTC 无会话但 `AudioEngine` 在播放(GSMTC 初始化失败或会话丢失的兜底):从 `AudioEngine.state()` + 播放队列聚合出 `NowPlaying`(`isThing: true`);控制指令由 server 复用 `music-smtc-button` 事件(同名、同 payload)emit 给前端执行。**既有架构约束**:队列控制逻辑(toggle/next/prev/播放模式)在前端 `feiniuStore`,AudioEngine 本身只有 play/set_playing/seek/stop——兜底路径依赖 WebView 存活,WebView 未就绪时直接回 `cmd-ack { ok: false, error: "frontend-unavailable" }`。
- 两者都无:`status: 'stopped'`,手机端显示"电脑未在播放"。
### 5.3 前端侧
- `src/modules/music/components/settings/RemoteSettings.vue`:总开关、端口、设备列表(在线状态/撤销)、「连接手机」按钮 → 配对码 + 二维码(`qrcode` 库,5s 轮询 status 刷新倒计时/在线态)。
- 状态存放:P0 用 RemoteSettings **组件本地状态**(5s 轮询 `remote_status`),不扩 musicStore——当前无其他消费方;遥控 UI 出现共享需求时再入 store。
- `constants.rs`:`REMOTE_WS_*` 等消息类型常量(如需要);本功能的"事件"主要是 WS 而非 Tauri event,前端基本只走 invoke + bindings。
### 5.4 生命周期
- 随应用启动初始化(不随模块启用——music 默认启用且常驻),`remote_enabled = false` 时仅不启服务/beacon,GSMTC 监视可保持惰性。
- 应用退出:axum graceful shutdown、beacon 停发(`cleanup_on_exit` 挂钩,参照 `MusicManager::cleanup_on_exit` 范式)。
- 系统休眠/网络切换:WS 断开由心跳判活;beacon 无状态持续广播即可,无需额外处理。
---
## 6. 关键实现细节与已知的坑
1. **GSMTC 在非打包桌面应用可用**(unpackaged desktop app 明确支持,1809+)。不要被"WinRT 需要 package identity"的泛泛说法劝退——GSMTC 不在受限之列,开源社区大量此类工具可佐证。**2026-09-25 已实证**:`examples/gsmtc_probe.rs`(unpackaged 控制台进程)跑通,读到当前会话元数据/状态/时间轴,核心假设成立。
2. **封面(Thumbnail)是 `RandomAccessStreamReference`**:`OpenReadAsync()` → 按 `ContentType`(image/png|jpeg)读全量字节 → 以 `hash(sourceApp + title + album + 尺寸)` 为键存内存 LRU(上限 ~20 张)。推送里只带 `coverHash`,封面走 HTTP 拉取,避免 WS 帧被几百 KB 图片打爆。
3. **事件风暴节流**:`TimelinePropertiesChanged` 在部分播放器上高频触发(每次内部时钟更新都发)。聚合层统一节流:任何状态变更合并后**最快 1Hz** 推送 `state`;进度靠手机端 `positionSec + elapsed` 本地推算(`status=playing` 时每秒 +1,收到新 `state` 校准),不依赖高频推送。**例外**:由 `cmd` 触发的状态变更立即推一帧(绕过 1Hz 节流),避免按钮"没反应"的体感——节流仅约束进度等自然高频变更。
4. **进度推算基准用 `TimelineProperties.LastUpdatedTime`**,不要用"收到事件的本地时刻"——事件分发有延迟,`LastUpdatedTime` 是播放器侧的权威时间戳。(本条约束 **Thing 侧**把 GSMTC 事件组装成 `positionSec/positionUpdatedAtMs` 的动作;**手机侧** elapsed 的起算基准见 §6.10,两层不要混用。)
5. **会话 key 的稳定性**:GSMTC 无显式 sessionId,用 `SourceAppUserModelId` 作 key;同一应用双会话(极少见)时后者覆盖前者,P1 的多会话切换再处理。
6. **`Try*Async` 的返回值不可全信**:部分播放器对不可用操作静默成功,回执只做 UI 轻提示,真实状态以下一帧 `state` 为准(`canControl` 能力位已尽力过滤)。
7. **AUMID → 友好名**:`SourceAppUserModelId` 是 `PackageFamilyName!App` 或注册表 AUMID,显示名需查 `Get-StartApps` 等价逻辑(注册表 `HKCU\Software\Classes\AppUserModelId`);先显示末段兜底,友好名缓存 LRU。
8. **防火墙弹窗只出现一次**(每个 exe 路径 × 网络类型),开发期 `tauri dev` 与正式版 exe 路径不同会各弹一次,属预期。
9. **Windows 通知区域"媒体"浮层与 GSMTC 互不干扰**:`smtc.rs` 的上报会话照常工作;手机控制 Thing 自身时,系统面板同步可见,是 feature 不是 bug。
10. **进度推算的时钟基准分两层,不要混用**:Thing 侧组装 `positionSec/positionUpdatedAtMs` 用 `TimelineProperties.LastUpdatedTime`(§6.4);手机侧 `elapsed` **一律以本地收到该条 `state` 的时刻起算**,禁止拿 `positionUpdatedAtMs` 与手机本机时间直接做差——电脑时钟偏差(手动对时/休眠漂移可差数秒以上)会整体拖偏进度条。手机端检测到两端时钟偏差 >5s 时冻结推算、只显示基准值,等待下一条 `state` 校准。两端时钟正常时(NTP 同步)此方案残差 ≤ 推送延迟(LAN 上 <1s,且播放中 ~1Hz 校准)。
---
## 7. 分阶段计划
### P0:可用版本(目标:手机能看到并控制电脑当前播放)
- [x] `windows` crate 开 `Media_Control` feature;10 行探测 demo 验证 GSMTC 在本机可用 —— **2026-09-25 实测通过**(`examples/gsmtc_probe.rs`,unpackaged 控制台进程:读到 1 会话 + 元数据/状态/时间轴全通;注意 `GetSessions`/`GetCurrentSession` 是同步 API,见 §3.1)
- [x] `remote/proto.rs`:类型定义(serde,未进 specta——WS 对端是手机,Thing 前端不消费)+ 单测(序列化往返/时间换算/会话 key)——**2026-09-26 完成,8 单测全绿**
- [x] `remote/glsmtc.rs`:初始化、事件订阅、`NowPlaying` 聚合、封面 LRU、节流(1Hz + cmd Force 例外)——**完成**;订阅 P0 只挂 Manager 级两事件 + 500ms 节拍轮询(会话级事件需随会话订阅/退订,列入 P1)
- [x] `remote/server.rs`:axum 路由 + WS 会话表 + 广播 + 心跳判活 + Bearer/hello 鉴权(+ /pair 限速、封面 token 走 query)——**完成**
- [x] `remote/discovery.rs`:UDP beacon(GetAdaptersAddresses 各网卡定向广播)——**完成**
- [x] `remote/pairing.rs`:配对码 + token 签发 + 设备表(keyring `music-remote-token-*`)——**完成**(单测含限速)
- [x] 控制指令:play/pause/toggle/next/prev/stop/seek → `Try*Async`(spawn_blocking);**Thing 自身 seek 直通 AudioEngine**(SMTC 回环无 seek 通道)——**完成**
- [x] 命令注册(collect_commands + generate_handler 双处)+ `RemoteSettings.vue`(开关/配对二维码/设备列表;qrcode 库前端生成)——**完成**;改为组件本地状态,不扩 musicStore(当前无其他消费方,需要时再入 store)
- [x] `AudioEngine` 兜底聚合(+ `SmtcMetaCache` 回填标题/歌手/专辑)——**完成**
- [x] 运行时冒烟(2026-09-26):自启绑定 `0.0.0.0:26124` ✓、beacon 实收(`addrs=["192.168.110.40"]`、deviceId 落盘)✓、`/api/state` 401 ✓、`/pair` 错码 403 ✓、日志「GSMTC 已初始化(专用线程 MTA)」✓、运行时 bindings 导出含 remote 命令 ✓
- [x] 联调:**真机 E2E 完成(2026-09-26)**——LFMusic 真机客户端全流程实测:配对码 142919 → `/pair` 成功(192.168.110.27)→ WS hello 鉴权 → state 推送(封面/元数据/thing.self/能力位)→ 播放暂停上下首控制生效 → App 重启后自动重连。过程修复:手机端 deviceId 语义(存电脑 id 而非 Thing 分配的行 id)与对端显示名两处关联 bug
- [ ] P0 验收口径(联调时执行):遥控界面显示 GSMTC `GetCurrentSession` 判定的活跃会话("最近操作"语义,多会话切换只留 UI 入口);进度推算按 §6.10 时钟基准联调;`cmd` 后 1s 内看到状态变化
### P1:体验完善 —— **2026-09-26 除两项暂缓外全部完成**
- [ ] mDNS 发现(mdns-sd 注册 `_thingmusic._tcp`)——**暂缓**:beacon 在目标网络 100% 可用且扫码兜底已覆盖;双端 mDNS(含 Android MulticastLock/Kotlin 桥)成本高、当前无失效场景驱动,等 beacon 实际失效案例再做
- [x] 多会话列表与手动切换——**完成**:`sessions` WS 消息(watch 变化推送 + 连接首帧)+ `select` 动作(**WinRT 无 SetCurrentSession,实测修正**:Thing 侧选中覆盖,空 id = 跟随系统 current;选中会话消失自动回落);手机端 chips UI(高亮 `isCurrent`)+「跟随系统」
- [x] **会话级事件精细化订阅**——**完成**:`SessionSubs` 随目标会话换绑 `MediaPropertiesChanged`/`TimelinePropertiesChanged`/`PlaybackInfoChanged`(切换时先退订后订阅,线程退出统一清理);Manager 级两事件 + 500ms 节拍轮询保留为保底
- [x] 系统音量控制 + 手机端音量条——**完成**:`volume.rs`(MMDevice → `IAudioEndpointVolume`,每次现取 COM 对象避免 Send/Sync 争议);监视线程 500ms 轮询进 `NowPlaying.volume/muted`(指纹纳入、变化即推);`volume` 动作 0~1、**>0 自动解除静音**;手机端 🔊 音量条(松手发送)
- [x] Thing 直通控制路径评估——**评估结论:落地直通**:`isThing` 按钮类指令直接 emit `music-smtc-button`(跳过 GSMTC→系统→SMTC 回环,少一跳系统派发延迟);seek 本就直通 AudioEngine;非 Thing 会话仍走 GSMTC `Try*Async`。系统面板同步不受影响(面板状态由前端持续上报 smtc.rs)。**真机复测**:非 Thing 路径(QQMusic 播放恢复)通过;isThing 直通与 P0 事件链同码,待 Thing 下次自身播放时自然覆盖
- [x] AUMID 友好名缓存、封面本地持久化缓存——**完成**:`friendly_name`(`HKCU\Software\Classes\AppUserModelId\<aumid>\DisplayName` 查询 + 128 条缓存,查不到退回 AUMID 简化段;路径形 AUMID 跳过注册表);`CoverStore` 写透 `{app_data}/remote_covers`(内存+磁盘双层 LRU 各 20 张,冷启动可回源)。**真机复测**:友好名生效(QQMusic / Microsoft.ZuneMusic);持久化目录已创建,落盘写入待下次取到封面时自然验证(当前可见会话均无缩略图)
- [ ] 手机端通知栏/锁屏媒体控件联动(LFMusic 侧 native-audio / MediaSession,见对端文档)——**暂缓**:被 LFMusic M1(集成 `tauri-plugin-native-audio`)阻塞,M1 完成后按对端文档回填
### P2:增强(按需)
- [ ] 自签 TLS(rcgen + rustls,二维码带证书指纹)
- [ ] 投播:手机浏览 Thing 曲库 → 远程下发放进 Thing 播放队列(`/queue` 端点 + AudioEngine 队列 API 暴露)
- [ ] 歌词推送(Thing 已有 lyric 能力,同步到手机端滚动显示)
- [ ] 多电脑:beacon 天然支持,配对表按 deviceId 区分,UI 侧完善
---
## 8. 风险与开放问题
| 风险/问题 | 影响 | 对策 |
|---|---|---|
| GSMTC 某播放器不上报专辑/封面(上报方行为,非 bug) | 手机端显示缺字段 | UI 兜底占位;Thing 自身播放时从曲库元数据补全(lofty 已有) |
| 路由器 AP 隔离导致广播不可达 | 手机发现不了电脑 | 扫码/手输 IP 兜底(P0 已含);mDNS 同样受影响,不是银弹 |
| 防火墙/杀软拦截 LAN 监听 | 手机连不上 | 设置页说明 + 连接失败诊断提示(检测本机端口监听、提示放行) |
| 手机休眠断 WS | 状态不实时 | 心跳 + 重连退避(手机端职责,见对端文档);恢复前台即拉 `/api/state` 快照 |
| `TryChangePlaybackPositionAsync` 部分应用不支持 | seek 无效 | `canControl.seek` 能力位隐藏进度条拖动 |
| 多网段/VPN 虚拟网卡产生杂音 beacon | 发现列表脏数据 | beacon 携带本机各网卡地址,手机端按连通性优选;显示名可区分 |
**开放问题**(实施前确认):
1. 是否需要"电脑端显示已连接手机"的托盘/OSD 提示?(倾向 P1,托盘菜单加一行在线设备数即可)
2. 投播的队列控制 API 形态(P2 前与 LFMusic 端一起定)。
3. 遥控界面是否需要歌词显示?用户需求"显示音乐信息"是否含歌词——Thing 已有 lyric 能力,但"歌词推送"列在 P2,需两端确认是否提前。
4. 音量控制是否提前到 P0?用户"控制电脑端"可能隐含音量——当前计划在 P1(`IAudioEndpointVolume`)。
+60
View File
@@ -24,6 +24,7 @@
"clsx": "^2.1.1", "clsx": "^2.1.1",
"pinia": "^3.0.4", "pinia": "^3.0.4",
"pinyin-pro": "^3.28.2", "pinyin-pro": "^3.28.2",
"qrcode": "^1.5.4",
"reka-ui": "^2.10.1", "reka-ui": "^2.10.1",
"tailwind-merge": "^3.6.0", "tailwind-merge": "^3.6.0",
"tailwindcss": "^4.3.2", "tailwindcss": "^4.3.2",
@@ -34,6 +35,7 @@
"devDependencies": { "devDependencies": {
"@tauri-apps/cli": "^2", "@tauri-apps/cli": "^2",
"@types/node": "^26.1.1", "@types/node": "^26.1.1",
"@types/qrcode": "^1.5.6",
"@vitejs/plugin-vue": "^5.2.1", "@vitejs/plugin-vue": "^5.2.1",
"@vue/eslint-config-typescript": "^14.9.0", "@vue/eslint-config-typescript": "^14.9.0",
"eslint": "^10.11.0", "eslint": "^10.11.0",
@@ -296,6 +298,8 @@
"@types/node": ["@types/node@26.1.1", "https://registry.npmmirror.com/@types/node/-/node-26.1.1.tgz", { "dependencies": { "undici-types": "~8.3.0" } }, "sha512-nxAkRSVkN1Y0JC1W8ky/fTfkGsMmcrRsbx+3XoZE+rMOX71kLYTV7fLXpqud1GpbpP5TuffXFqfX7fH2GgZREw=="], "@types/node": ["@types/node@26.1.1", "https://registry.npmmirror.com/@types/node/-/node-26.1.1.tgz", { "dependencies": { "undici-types": "~8.3.0" } }, "sha512-nxAkRSVkN1Y0JC1W8ky/fTfkGsMmcrRsbx+3XoZE+rMOX71kLYTV7fLXpqud1GpbpP5TuffXFqfX7fH2GgZREw=="],
"@types/qrcode": ["@types/qrcode@1.5.6", "https://registry.npmmirror.com/@types/qrcode/-/qrcode-1.5.6.tgz", { "dependencies": { "@types/node": "*" } }, "sha512-te7NQcV2BOvdj2b1hCAHzAoMNuj65kNBMz0KBaxM6c3VGBOhU0dURQKOtH8CFNI/dsKkwlv32p26qYQTWoB5bw=="],
"@types/sortablejs": ["@types/sortablejs@1.15.9", "https://registry.npmmirror.com/@types/sortablejs/-/sortablejs-1.15.9.tgz", {}, "sha512-7HP+rZGE2p886PKV9c9OJzLBI6BBJu1O7lJGYnPyG3fS4/duUCcngkNCjsLwIMV+WMqANe3tt4irrXHSIe68OQ=="], "@types/sortablejs": ["@types/sortablejs@1.15.9", "https://registry.npmmirror.com/@types/sortablejs/-/sortablejs-1.15.9.tgz", {}, "sha512-7HP+rZGE2p886PKV9c9OJzLBI6BBJu1O7lJGYnPyG3fS4/duUCcngkNCjsLwIMV+WMqANe3tt4irrXHSIe68OQ=="],
"@types/web-bluetooth": ["@types/web-bluetooth@0.0.21", "https://registry.npmmirror.com/@types/web-bluetooth/-/web-bluetooth-0.0.21.tgz", {}, "sha512-oIQLCGWtcFZy2JW77j9k8nHzAOpqMHLQejDA48XXMWH6tjCQHz5RCFz1bzsmROyL6PUm+LLnUiI4BCn221inxA=="], "@types/web-bluetooth": ["@types/web-bluetooth@0.0.21", "https://registry.npmmirror.com/@types/web-bluetooth/-/web-bluetooth-0.0.21.tgz", {}, "sha512-oIQLCGWtcFZy2JW77j9k8nHzAOpqMHLQejDA48XXMWH6tjCQHz5RCFz1bzsmROyL6PUm+LLnUiI4BCn221inxA=="],
@@ -386,6 +390,10 @@
"alien-signals": ["alien-signals@1.0.13", "https://registry.npmmirror.com/alien-signals/-/alien-signals-1.0.13.tgz", {}, "sha512-OGj9yyTnJEttvzhTUWuscOvtqxq5vrhF7vL9oS0xJ2mK0ItPYP1/y+vCFebfxoEyAz0++1AIwJ5CMr+Fk3nDmg=="], "alien-signals": ["alien-signals@1.0.13", "https://registry.npmmirror.com/alien-signals/-/alien-signals-1.0.13.tgz", {}, "sha512-OGj9yyTnJEttvzhTUWuscOvtqxq5vrhF7vL9oS0xJ2mK0ItPYP1/y+vCFebfxoEyAz0++1AIwJ5CMr+Fk3nDmg=="],
"ansi-regex": ["ansi-regex@5.0.1", "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-5.0.1.tgz", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],
"ansi-styles": ["ansi-styles@4.3.0", "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-4.3.0.tgz", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
"aria-hidden": ["aria-hidden@1.2.6", "https://registry.npmmirror.com/aria-hidden/-/aria-hidden-1.2.6.tgz", { "dependencies": { "tslib": "^2.0.0" } }, "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA=="], "aria-hidden": ["aria-hidden@1.2.6", "https://registry.npmmirror.com/aria-hidden/-/aria-hidden-1.2.6.tgz", { "dependencies": { "tslib": "^2.0.0" } }, "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA=="],
"balanced-match": ["balanced-match@4.0.4", "https://registry.npmmirror.com/balanced-match/-/balanced-match-4.0.4.tgz", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="], "balanced-match": ["balanced-match@4.0.4", "https://registry.npmmirror.com/balanced-match/-/balanced-match-4.0.4.tgz", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="],
@@ -400,10 +408,18 @@
"cacheable": ["cacheable@2.5.0", "https://registry.npmmirror.com/cacheable/-/cacheable-2.5.0.tgz", { "dependencies": { "@cacheable/memory": "^2.2.0", "@cacheable/utils": "^2.5.0", "hookified": "^1.15.0", "keyv": "^5.6.0", "qified": "^0.10.1" } }, "sha512-60cyAOytib/OzBw1JNSoSV/boK1AtHryDIjvVBk7XbN4ugfkM3+Sry7fEjNgPMGgOjuaZPAp8ruZ0Cxafwyq9g=="], "cacheable": ["cacheable@2.5.0", "https://registry.npmmirror.com/cacheable/-/cacheable-2.5.0.tgz", { "dependencies": { "@cacheable/memory": "^2.2.0", "@cacheable/utils": "^2.5.0", "hookified": "^1.15.0", "keyv": "^5.6.0", "qified": "^0.10.1" } }, "sha512-60cyAOytib/OzBw1JNSoSV/boK1AtHryDIjvVBk7XbN4ugfkM3+Sry7fEjNgPMGgOjuaZPAp8ruZ0Cxafwyq9g=="],
"camelcase": ["camelcase@5.3.1", "https://registry.npmmirror.com/camelcase/-/camelcase-5.3.1.tgz", {}, "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg=="],
"class-variance-authority": ["class-variance-authority@0.7.1", "https://registry.npmmirror.com/class-variance-authority/-/class-variance-authority-0.7.1.tgz", { "dependencies": { "clsx": "^2.1.1" } }, "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg=="], "class-variance-authority": ["class-variance-authority@0.7.1", "https://registry.npmmirror.com/class-variance-authority/-/class-variance-authority-0.7.1.tgz", { "dependencies": { "clsx": "^2.1.1" } }, "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg=="],
"cliui": ["cliui@6.0.0", "https://registry.npmmirror.com/cliui/-/cliui-6.0.0.tgz", { "dependencies": { "string-width": "^4.2.0", "strip-ansi": "^6.0.0", "wrap-ansi": "^6.2.0" } }, "sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ=="],
"clsx": ["clsx@2.1.1", "https://registry.npmmirror.com/clsx/-/clsx-2.1.1.tgz", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="], "clsx": ["clsx@2.1.1", "https://registry.npmmirror.com/clsx/-/clsx-2.1.1.tgz", {}, "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA=="],
"color-convert": ["color-convert@2.0.1", "https://registry.npmmirror.com/color-convert/-/color-convert-2.0.1.tgz", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="],
"color-name": ["color-name@1.1.4", "https://registry.npmmirror.com/color-name/-/color-name-1.1.4.tgz", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="],
"copy-anything": ["copy-anything@4.0.5", "https://registry.npmmirror.com/copy-anything/-/copy-anything-4.0.5.tgz", { "dependencies": { "is-what": "^5.2.0" } }, "sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA=="], "copy-anything": ["copy-anything@4.0.5", "https://registry.npmmirror.com/copy-anything/-/copy-anything-4.0.5.tgz", { "dependencies": { "is-what": "^5.2.0" } }, "sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA=="],
"cross-spawn": ["cross-spawn@7.0.6", "https://registry.npmmirror.com/cross-spawn/-/cross-spawn-7.0.6.tgz", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="], "cross-spawn": ["cross-spawn@7.0.6", "https://registry.npmmirror.com/cross-spawn/-/cross-spawn-7.0.6.tgz", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
@@ -416,12 +432,18 @@
"debug": ["debug@4.4.3", "https://registry.npmmirror.com/debug/-/debug-4.4.3.tgz", { "dependencies": { "ms": "^2.1.3" }, "peerDependencies": { "supports-color": "*" }, "optionalPeers": ["supports-color"] }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="], "debug": ["debug@4.4.3", "https://registry.npmmirror.com/debug/-/debug-4.4.3.tgz", { "dependencies": { "ms": "^2.1.3" }, "peerDependencies": { "supports-color": "*" }, "optionalPeers": ["supports-color"] }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="],
"decamelize": ["decamelize@1.2.0", "https://registry.npmmirror.com/decamelize/-/decamelize-1.2.0.tgz", {}, "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA=="],
"deep-is": ["deep-is@0.1.4", "https://registry.npmmirror.com/deep-is/-/deep-is-0.1.4.tgz", {}, "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="], "deep-is": ["deep-is@0.1.4", "https://registry.npmmirror.com/deep-is/-/deep-is-0.1.4.tgz", {}, "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="],
"defu": ["defu@6.1.7", "https://registry.npmmirror.com/defu/-/defu-6.1.7.tgz", {}, "sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ=="], "defu": ["defu@6.1.7", "https://registry.npmmirror.com/defu/-/defu-6.1.7.tgz", {}, "sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ=="],
"detect-libc": ["detect-libc@2.1.2", "https://registry.npmmirror.com/detect-libc/-/detect-libc-2.1.2.tgz", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="], "detect-libc": ["detect-libc@2.1.2", "https://registry.npmmirror.com/detect-libc/-/detect-libc-2.1.2.tgz", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="],
"dijkstrajs": ["dijkstrajs@1.0.3", "https://registry.npmmirror.com/dijkstrajs/-/dijkstrajs-1.0.3.tgz", {}, "sha512-qiSlmBq9+BCdCA/L46dw8Uy93mloxsPSbwnm5yrKn2vMPiy8KyAskTF6zuV/j5BMsmOGZDPs7KjU+mjb670kfA=="],
"emoji-regex": ["emoji-regex@8.0.0", "https://registry.npmmirror.com/emoji-regex/-/emoji-regex-8.0.0.tgz", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
"enhanced-resolve": ["enhanced-resolve@5.21.6", "https://registry.npmmirror.com/enhanced-resolve/-/enhanced-resolve-5.21.6.tgz", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.3.3" } }, "sha512-aNnGCvbJ/RIyWo1IuhNdVjnNF+EjH9wpzpNHt+ci/m9He9LJvUN8wrCcXjp9cWsGNAuvSpVFTx/vraAFQ8qGjQ=="], "enhanced-resolve": ["enhanced-resolve@5.21.6", "https://registry.npmmirror.com/enhanced-resolve/-/enhanced-resolve-5.21.6.tgz", { "dependencies": { "graceful-fs": "^4.2.4", "tapable": "^2.3.3" } }, "sha512-aNnGCvbJ/RIyWo1IuhNdVjnNF+EjH9wpzpNHt+ci/m9He9LJvUN8wrCcXjp9cWsGNAuvSpVFTx/vraAFQ8qGjQ=="],
"entities": ["entities@7.0.1", "https://registry.npmmirror.com/entities/-/entities-7.0.1.tgz", {}, "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA=="], "entities": ["entities@7.0.1", "https://registry.npmmirror.com/entities/-/entities-7.0.1.tgz", {}, "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA=="],
@@ -474,6 +496,8 @@
"fsevents": ["fsevents@2.3.3", "https://registry.npmmirror.com/fsevents/-/fsevents-2.3.3.tgz", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="], "fsevents": ["fsevents@2.3.3", "https://registry.npmmirror.com/fsevents/-/fsevents-2.3.3.tgz", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
"get-caller-file": ["get-caller-file@2.0.5", "https://registry.npmmirror.com/get-caller-file/-/get-caller-file-2.0.5.tgz", {}, "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg=="],
"glob-parent": ["glob-parent@6.0.2", "https://registry.npmmirror.com/glob-parent/-/glob-parent-6.0.2.tgz", { "dependencies": { "is-glob": "^4.0.3" } }, "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="], "glob-parent": ["glob-parent@6.0.2", "https://registry.npmmirror.com/glob-parent/-/glob-parent-6.0.2.tgz", { "dependencies": { "is-glob": "^4.0.3" } }, "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="],
"graceful-fs": ["graceful-fs@4.2.11", "https://registry.npmmirror.com/graceful-fs/-/graceful-fs-4.2.11.tgz", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="], "graceful-fs": ["graceful-fs@4.2.11", "https://registry.npmmirror.com/graceful-fs/-/graceful-fs-4.2.11.tgz", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
@@ -492,6 +516,8 @@
"is-extglob": ["is-extglob@2.1.1", "https://registry.npmmirror.com/is-extglob/-/is-extglob-2.1.1.tgz", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="], "is-extglob": ["is-extglob@2.1.1", "https://registry.npmmirror.com/is-extglob/-/is-extglob-2.1.1.tgz", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="],
"is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "https://registry.npmmirror.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],
"is-glob": ["is-glob@4.0.3", "https://registry.npmmirror.com/is-glob/-/is-glob-4.0.3.tgz", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="], "is-glob": ["is-glob@4.0.3", "https://registry.npmmirror.com/is-glob/-/is-glob-4.0.3.tgz", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="],
"is-number": ["is-number@7.0.0", "https://registry.npmmirror.com/is-number/-/is-number-7.0.0.tgz", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="], "is-number": ["is-number@7.0.0", "https://registry.npmmirror.com/is-number/-/is-number-7.0.0.tgz", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="],
@@ -564,6 +590,8 @@
"p-locate": ["p-locate@5.0.0", "https://registry.npmmirror.com/p-locate/-/p-locate-5.0.0.tgz", { "dependencies": { "p-limit": "^3.0.2" } }, "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="], "p-locate": ["p-locate@5.0.0", "https://registry.npmmirror.com/p-locate/-/p-locate-5.0.0.tgz", { "dependencies": { "p-limit": "^3.0.2" } }, "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="],
"p-try": ["p-try@2.2.0", "https://registry.npmmirror.com/p-try/-/p-try-2.2.0.tgz", {}, "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ=="],
"path-browserify": ["path-browserify@1.0.1", "https://registry.npmmirror.com/path-browserify/-/path-browserify-1.0.1.tgz", {}, "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g=="], "path-browserify": ["path-browserify@1.0.1", "https://registry.npmmirror.com/path-browserify/-/path-browserify-1.0.1.tgz", {}, "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g=="],
"path-exists": ["path-exists@4.0.0", "https://registry.npmmirror.com/path-exists/-/path-exists-4.0.0.tgz", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="], "path-exists": ["path-exists@4.0.0", "https://registry.npmmirror.com/path-exists/-/path-exists-4.0.0.tgz", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="],
@@ -580,6 +608,8 @@
"pinyin-pro": ["pinyin-pro@3.29.4", "https://registry.npmmirror.com/pinyin-pro/-/pinyin-pro-3.29.4.tgz", {}, "sha512-SPXpDT2cHEy+d26V1RXYMlVzXN42hotFAak1fzyWPi4o2dKXb61UqD4pzxDJHwk6gbv8vQ6EfErd+hYX0Qhzug=="], "pinyin-pro": ["pinyin-pro@3.29.4", "https://registry.npmmirror.com/pinyin-pro/-/pinyin-pro-3.29.4.tgz", {}, "sha512-SPXpDT2cHEy+d26V1RXYMlVzXN42hotFAak1fzyWPi4o2dKXb61UqD4pzxDJHwk6gbv8vQ6EfErd+hYX0Qhzug=="],
"pngjs": ["pngjs@5.0.0", "https://registry.npmmirror.com/pngjs/-/pngjs-5.0.0.tgz", {}, "sha512-40QW5YalBNfQo5yRYmiw7Yz6TKKVr3h6970B2YE+3fQpsWcrbj1PzJgxeJ19DRQjhMbKPIuMY8rFaXc8moolVw=="],
"postcss": ["postcss@8.5.19", "https://registry.npmmirror.com/postcss/-/postcss-8.5.19.tgz", { "dependencies": { "nanoid": "^3.3.12", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-Mz8SaolMd8nB+G13WkORcxQKHZ/NE4xXevtkJHVuG+guo9/wYKlIMTKAqGdEmYOXR2ijPjTYNHssizdaVSUNdQ=="], "postcss": ["postcss@8.5.19", "https://registry.npmmirror.com/postcss/-/postcss-8.5.19.tgz", { "dependencies": { "nanoid": "^3.3.12", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-Mz8SaolMd8nB+G13WkORcxQKHZ/NE4xXevtkJHVuG+guo9/wYKlIMTKAqGdEmYOXR2ijPjTYNHssizdaVSUNdQ=="],
"postcss-selector-parser": ["postcss-selector-parser@7.1.6", "https://registry.npmmirror.com/postcss-selector-parser/-/postcss-selector-parser-7.1.6.tgz", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-7qASPzhKF2l2KLboRZux8CCTRMdGiV08vWmyKzPz22qZ7ZjQBOeY7rNzNoCLSUiftJ7HUq0GERHmxw/t0dCdMw=="], "postcss-selector-parser": ["postcss-selector-parser@7.1.6", "https://registry.npmmirror.com/postcss-selector-parser/-/postcss-selector-parser-7.1.6.tgz", { "dependencies": { "cssesc": "^3.0.0", "util-deprecate": "^1.0.2" } }, "sha512-7qASPzhKF2l2KLboRZux8CCTRMdGiV08vWmyKzPz22qZ7ZjQBOeY7rNzNoCLSUiftJ7HUq0GERHmxw/t0dCdMw=="],
@@ -590,10 +620,16 @@
"qified": ["qified@0.10.1", "https://registry.npmmirror.com/qified/-/qified-0.10.1.tgz", { "dependencies": { "hookified": "^2.1.1" } }, "sha512-+Owyggi9IxT1ePKGafcI87ubSmxol6smwJ+RAHDQlx9+9cPwFWDiKFFCPuWhr9ignlGpZ9vDQLw67N4dcTVFEA=="], "qified": ["qified@0.10.1", "https://registry.npmmirror.com/qified/-/qified-0.10.1.tgz", { "dependencies": { "hookified": "^2.1.1" } }, "sha512-+Owyggi9IxT1ePKGafcI87ubSmxol6smwJ+RAHDQlx9+9cPwFWDiKFFCPuWhr9ignlGpZ9vDQLw67N4dcTVFEA=="],
"qrcode": ["qrcode@1.5.4", "https://registry.npmmirror.com/qrcode/-/qrcode-1.5.4.tgz", { "dependencies": { "dijkstrajs": "^1.0.1", "pngjs": "^5.0.0", "yargs": "^15.3.1" }, "bin": { "qrcode": "bin/qrcode" } }, "sha512-1ca71Zgiu6ORjHqFBDpnSMTR2ReToX4l1Au1VFLyVeBTFavzQnv5JxMFr3ukHVKpSrSA2MCk0lNJSykjUfz7Zg=="],
"queue-microtask": ["queue-microtask@1.2.3", "https://registry.npmmirror.com/queue-microtask/-/queue-microtask-1.2.3.tgz", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="], "queue-microtask": ["queue-microtask@1.2.3", "https://registry.npmmirror.com/queue-microtask/-/queue-microtask-1.2.3.tgz", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="],
"reka-ui": ["reka-ui@2.10.1", "https://registry.npmmirror.com/reka-ui/-/reka-ui-2.10.1.tgz", { "dependencies": { "@floating-ui/dom": "^1.6.13", "@floating-ui/vue": "^1.1.6", "@internationalized/date": "^3.5.0", "@internationalized/number": "^3.5.0", "@tanstack/vue-virtual": "^3.12.0", "@vueuse/core": "^14.1.0", "@vueuse/shared": "^14.1.0", "aria-hidden": "^1.2.4", "defu": "^6.1.5", "ohash": "^2.0.11" }, "peerDependencies": { "vue": ">= 3.4.0" } }, "sha512-drcOQ4rQtDYAcGCsyQBqQg8QQ+H3B+zDaMJU0h8KPEPMa7g9BHu3zcOi4OB39XJSWizceFoNO0Z9tctSGLOXqg=="], "reka-ui": ["reka-ui@2.10.1", "https://registry.npmmirror.com/reka-ui/-/reka-ui-2.10.1.tgz", { "dependencies": { "@floating-ui/dom": "^1.6.13", "@floating-ui/vue": "^1.1.6", "@internationalized/date": "^3.5.0", "@internationalized/number": "^3.5.0", "@tanstack/vue-virtual": "^3.12.0", "@vueuse/core": "^14.1.0", "@vueuse/shared": "^14.1.0", "aria-hidden": "^1.2.4", "defu": "^6.1.5", "ohash": "^2.0.11" }, "peerDependencies": { "vue": ">= 3.4.0" } }, "sha512-drcOQ4rQtDYAcGCsyQBqQg8QQ+H3B+zDaMJU0h8KPEPMa7g9BHu3zcOi4OB39XJSWizceFoNO0Z9tctSGLOXqg=="],
"require-directory": ["require-directory@2.1.1", "https://registry.npmmirror.com/require-directory/-/require-directory-2.1.1.tgz", {}, "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q=="],
"require-main-filename": ["require-main-filename@2.0.0", "https://registry.npmmirror.com/require-main-filename/-/require-main-filename-2.0.0.tgz", {}, "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg=="],
"reusify": ["reusify@1.1.0", "https://registry.npmmirror.com/reusify/-/reusify-1.1.0.tgz", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="], "reusify": ["reusify@1.1.0", "https://registry.npmmirror.com/reusify/-/reusify-1.1.0.tgz", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="],
"rfdc": ["rfdc@1.4.1", "https://registry.npmmirror.com/rfdc/-/rfdc-1.4.1.tgz", {}, "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA=="], "rfdc": ["rfdc@1.4.1", "https://registry.npmmirror.com/rfdc/-/rfdc-1.4.1.tgz", {}, "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA=="],
@@ -604,6 +640,8 @@
"semver": ["semver@7.8.5", "https://registry.npmmirror.com/semver/-/semver-7.8.5.tgz", { "bin": { "semver": "bin/semver.js" } }, "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA=="], "semver": ["semver@7.8.5", "https://registry.npmmirror.com/semver/-/semver-7.8.5.tgz", { "bin": { "semver": "bin/semver.js" } }, "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA=="],
"set-blocking": ["set-blocking@2.0.0", "https://registry.npmmirror.com/set-blocking/-/set-blocking-2.0.0.tgz", {}, "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw=="],
"shebang-command": ["shebang-command@2.0.0", "https://registry.npmmirror.com/shebang-command/-/shebang-command-2.0.0.tgz", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="], "shebang-command": ["shebang-command@2.0.0", "https://registry.npmmirror.com/shebang-command/-/shebang-command-2.0.0.tgz", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="],
"shebang-regex": ["shebang-regex@3.0.0", "https://registry.npmmirror.com/shebang-regex/-/shebang-regex-3.0.0.tgz", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="], "shebang-regex": ["shebang-regex@3.0.0", "https://registry.npmmirror.com/shebang-regex/-/shebang-regex-3.0.0.tgz", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="],
@@ -612,6 +650,10 @@
"speakingurl": ["speakingurl@14.0.1", "https://registry.npmmirror.com/speakingurl/-/speakingurl-14.0.1.tgz", {}, "sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ=="], "speakingurl": ["speakingurl@14.0.1", "https://registry.npmmirror.com/speakingurl/-/speakingurl-14.0.1.tgz", {}, "sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ=="],
"string-width": ["string-width@4.2.3", "https://registry.npmmirror.com/string-width/-/string-width-4.2.3.tgz", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
"strip-ansi": ["strip-ansi@6.0.1", "https://registry.npmmirror.com/strip-ansi/-/strip-ansi-6.0.1.tgz", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
"superjson": ["superjson@2.2.6", "https://registry.npmmirror.com/superjson/-/superjson-2.2.6.tgz", { "dependencies": { "copy-anything": "^4" } }, "sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA=="], "superjson": ["superjson@2.2.6", "https://registry.npmmirror.com/superjson/-/superjson-2.2.6.tgz", { "dependencies": { "copy-anything": "^4" } }, "sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA=="],
"tailwind-merge": ["tailwind-merge@3.6.0", "https://registry.npmmirror.com/tailwind-merge/-/tailwind-merge-3.6.0.tgz", {}, "sha512-uxL7qAVQriqRQPAyK3pj66VqskWqoZ37PW94jwOTwNfq/z9oyu1V+eqrZqtR2+fCiXdYOZe/Modt8GtvqNzu+w=="], "tailwind-merge": ["tailwind-merge@3.6.0", "https://registry.npmmirror.com/tailwind-merge/-/tailwind-merge-3.6.0.tgz", {}, "sha512-uxL7qAVQriqRQPAyK3pj66VqskWqoZ37PW94jwOTwNfq/z9oyu1V+eqrZqtR2+fCiXdYOZe/Modt8GtvqNzu+w=="],
@@ -660,10 +702,20 @@
"which": ["which@2.0.2", "https://registry.npmmirror.com/which/-/which-2.0.2.tgz", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="], "which": ["which@2.0.2", "https://registry.npmmirror.com/which/-/which-2.0.2.tgz", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="],
"which-module": ["which-module@2.0.1", "https://registry.npmmirror.com/which-module/-/which-module-2.0.1.tgz", {}, "sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ=="],
"word-wrap": ["word-wrap@1.2.5", "https://registry.npmmirror.com/word-wrap/-/word-wrap-1.2.5.tgz", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="], "word-wrap": ["word-wrap@1.2.5", "https://registry.npmmirror.com/word-wrap/-/word-wrap-1.2.5.tgz", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="],
"wrap-ansi": ["wrap-ansi@6.2.0", "https://registry.npmmirror.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA=="],
"xml-name-validator": ["xml-name-validator@5.0.0", "https://registry.npmmirror.com/xml-name-validator/-/xml-name-validator-5.0.0.tgz", {}, "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg=="], "xml-name-validator": ["xml-name-validator@5.0.0", "https://registry.npmmirror.com/xml-name-validator/-/xml-name-validator-5.0.0.tgz", {}, "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg=="],
"y18n": ["y18n@4.0.3", "https://registry.npmmirror.com/y18n/-/y18n-4.0.3.tgz", {}, "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ=="],
"yargs": ["yargs@15.4.1", "https://registry.npmmirror.com/yargs/-/yargs-15.4.1.tgz", { "dependencies": { "cliui": "^6.0.0", "decamelize": "^1.2.0", "find-up": "^4.1.0", "get-caller-file": "^2.0.1", "require-directory": "^2.1.1", "require-main-filename": "^2.0.0", "set-blocking": "^2.0.0", "string-width": "^4.2.0", "which-module": "^2.0.0", "y18n": "^4.0.0", "yargs-parser": "^18.1.2" } }, "sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A=="],
"yargs-parser": ["yargs-parser@18.1.3", "https://registry.npmmirror.com/yargs-parser/-/yargs-parser-18.1.3.tgz", { "dependencies": { "camelcase": "^5.0.0", "decamelize": "^1.2.0" } }, "sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ=="],
"yocto-queue": ["yocto-queue@0.1.0", "https://registry.npmmirror.com/yocto-queue/-/yocto-queue-0.1.0.tgz", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="], "yocto-queue": ["yocto-queue@0.1.0", "https://registry.npmmirror.com/yocto-queue/-/yocto-queue-0.1.0.tgz", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="],
"@eslint-community/eslint-utils/eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "https://registry.npmmirror.com/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="], "@eslint-community/eslint-utils/eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "https://registry.npmmirror.com/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="],
@@ -694,10 +746,18 @@
"reka-ui/@vueuse/shared": ["@vueuse/shared@14.3.0", "https://registry.npmmirror.com/@vueuse/shared/-/shared-14.3.0.tgz", { "peerDependencies": { "vue": "^3.5.0" } }, "sha512-bZpge9eSXwa4ToSiqJ7j6KRwhAsneMFoSz3LMWKQDkqimm3D/tbFlrklrs/IOqC8tEcYmXQZJ6N0UrjhBirVCg=="], "reka-ui/@vueuse/shared": ["@vueuse/shared@14.3.0", "https://registry.npmmirror.com/@vueuse/shared/-/shared-14.3.0.tgz", { "peerDependencies": { "vue": "^3.5.0" } }, "sha512-bZpge9eSXwa4ToSiqJ7j6KRwhAsneMFoSz3LMWKQDkqimm3D/tbFlrklrs/IOqC8tEcYmXQZJ6N0UrjhBirVCg=="],
"yargs/find-up": ["find-up@4.1.0", "https://registry.npmmirror.com/find-up/-/find-up-4.1.0.tgz", { "dependencies": { "locate-path": "^5.0.0", "path-exists": "^4.0.0" } }, "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw=="],
"@vue/language-core/minimatch/brace-expansion": ["brace-expansion@2.1.2", "https://registry.npmmirror.com/brace-expansion/-/brace-expansion-2.1.2.tgz", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-w5JZcKgdhDOgOwm8H+KgbosopHMuGcl6qbulwjtz3SM7I7P3yW1eAjzMPLrIE+NQ9vjgANKHWeMHnrT0OXW1oA=="], "@vue/language-core/minimatch/brace-expansion": ["brace-expansion@2.1.2", "https://registry.npmmirror.com/brace-expansion/-/brace-expansion-2.1.2.tgz", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-w5JZcKgdhDOgOwm8H+KgbosopHMuGcl6qbulwjtz3SM7I7P3yW1eAjzMPLrIE+NQ9vjgANKHWeMHnrT0OXW1oA=="],
"reka-ui/@vueuse/core/@vueuse/metadata": ["@vueuse/metadata@14.3.0", "https://registry.npmmirror.com/@vueuse/metadata/-/metadata-14.3.0.tgz", {}, "sha512-BwxmbAzwAVF50+MW57GXOUEV61nFBGnlBvrTqj49PqWJu3uw7hdu72ztXeZ33RdZtDY6kO+bfCAE1PCn88Tktw=="], "reka-ui/@vueuse/core/@vueuse/metadata": ["@vueuse/metadata@14.3.0", "https://registry.npmmirror.com/@vueuse/metadata/-/metadata-14.3.0.tgz", {}, "sha512-BwxmbAzwAVF50+MW57GXOUEV61nFBGnlBvrTqj49PqWJu3uw7hdu72ztXeZ33RdZtDY6kO+bfCAE1PCn88Tktw=="],
"yargs/find-up/locate-path": ["locate-path@5.0.0", "https://registry.npmmirror.com/locate-path/-/locate-path-5.0.0.tgz", { "dependencies": { "p-locate": "^4.1.0" } }, "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g=="],
"@vue/language-core/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "https://registry.npmmirror.com/balanced-match/-/balanced-match-1.0.2.tgz", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], "@vue/language-core/minimatch/brace-expansion/balanced-match": ["balanced-match@1.0.2", "https://registry.npmmirror.com/balanced-match/-/balanced-match-1.0.2.tgz", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="],
"yargs/find-up/locate-path/p-locate": ["p-locate@4.1.0", "https://registry.npmmirror.com/p-locate/-/p-locate-4.1.0.tgz", { "dependencies": { "p-limit": "^2.2.0" } }, "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A=="],
"yargs/find-up/locate-path/p-locate/p-limit": ["p-limit@2.3.0", "https://registry.npmmirror.com/p-limit/-/p-limit-2.3.0.tgz", { "dependencies": { "p-try": "^2.0.0" } }, "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w=="],
} }
} }
+2
View File
@@ -33,6 +33,7 @@
"clsx": "^2.1.1", "clsx": "^2.1.1",
"pinia": "^3.0.4", "pinia": "^3.0.4",
"pinyin-pro": "^3.28.2", "pinyin-pro": "^3.28.2",
"qrcode": "^1.5.4",
"reka-ui": "^2.10.1", "reka-ui": "^2.10.1",
"tailwind-merge": "^3.6.0", "tailwind-merge": "^3.6.0",
"tailwindcss": "^4.3.2", "tailwindcss": "^4.3.2",
@@ -43,6 +44,7 @@
"devDependencies": { "devDependencies": {
"@tauri-apps/cli": "^2", "@tauri-apps/cli": "^2",
"@types/node": "^26.1.1", "@types/node": "^26.1.1",
"@types/qrcode": "^1.5.6",
"@vitejs/plugin-vue": "^5.2.1", "@vitejs/plugin-vue": "^5.2.1",
"@vue/eslint-config-typescript": "^14.9.0", "@vue/eslint-config-typescript": "^14.9.0",
"eslint": "^10.11.0", "eslint": "^10.11.0",
+3
View File
@@ -438,6 +438,7 @@ checksum = "edca88bc138befd0323b20752846e6587272d3b03b0343c8ea28a6f819e6e71f"
dependencies = [ dependencies = [
"async-trait", "async-trait",
"axum-core 0.4.5", "axum-core 0.4.5",
"base64 0.22.1",
"bytes", "bytes",
"futures-util", "futures-util",
"http", "http",
@@ -456,8 +457,10 @@ dependencies = [
"serde_json", "serde_json",
"serde_path_to_error", "serde_path_to_error",
"serde_urlencoded", "serde_urlencoded",
"sha1 0.10.7",
"sync_wrapper", "sync_wrapper",
"tokio", "tokio",
"tokio-tungstenite",
"tower", "tower",
"tower-layer", "tower-layer",
"tower-service", "tower-service",
+21 -1
View File
@@ -41,7 +41,7 @@ chrono = "0.4"
reqwest = { version = "0.12", features = ["json", "stream", "multipart", "blocking"] } reqwest = { version = "0.12", features = ["json", "stream", "multipart", "blocking"] }
futures-util = "0.3" futures-util = "0.3"
tokio = { version = "1", features = ["io-util", "time", "rt-multi-thread", "macros", "sync", "fs", "net"] } tokio = { version = "1", features = ["io-util", "time", "rt-multi-thread", "macros", "sync", "fs", "net"] }
axum = "0.7" axum = { version = "0.7", features = ["ws"] }
url = "2" url = "2"
zip = "2" zip = "2"
dirs = "5" dirs = "5"
@@ -154,6 +154,12 @@ windows-sys = { version = "0.52", features = [
# 注意:0.52 起 ReadFile 定义在 Storage_FileSystem 但被 Win32_System_IO 特性门控, # 注意:0.52 起 ReadFile 定义在 Storage_FileSystem 但被 Win32_System_IO 特性门控,
# 两个特性必须同时开启,否则导入会解析失败。 # 两个特性必须同时开启,否则导入会解析失败。
"Win32_System_IO", "Win32_System_IO",
# 音乐模块「解密」:QQ音乐新版 musicex 的 ekey 不落盘,只能联网取;而
# authst 仅存在于 QQMusic.exe 运行期内存里 —— 需要进程枚举(ToolHelp:
# CreateToolhelp32Snapshot / Process32FirstW)与跨进程读内存
# (Diagnostics::Debug::ReadProcessMemory + System::Memory::VirtualQueryEx)。
"Win32_System_Diagnostics_ToolHelp",
"Win32_System_Diagnostics_Debug",
] } ] }
# Explorer ShellWindows COM:用于枚举已打开的资源管理器窗口并取当前路径 # Explorer ShellWindows COM:用于枚举已打开的资源管理器窗口并取当前路径
# (快速面板「用资源管理器打开」联动)。依赖 Win32_System_Com 特性。 # (快速面板「用资源管理器打开」联动)。依赖 Win32_System_Com 特性。
@@ -180,6 +186,20 @@ windows = { version = "0.52", features = [
# 专辑与封面不送达,且会话挂在浏览器进程 AUMID 上只显示「未知应用」。 # 专辑与封面不送达,且会话挂在浏览器进程 AUMID 上只显示「未知应用」。
"Media", "Media",
"Win32_System_WinRT", "Win32_System_WinRT",
# 音乐模块·手机遥控:GSMTC 全局会话管理器(Windows.Media.Control),
# 枚举/监视/控制系统全部 SMTC 会话(MUSIC_REMOTE_PLAN §3.1)
"Media_Control",
# 手机遥控·UDP beacon:GetAdaptersAddresses 枚举各网卡 IPv4/广播地址
# (多网卡/VPN 场景下定向广播,MUSIC_REMOTE_PLAN §3.3)。
# GetAdaptersAddresses 另受 Ndis + WinSock 两个 feature 门控(windows 0.52 源码 cfg)
"Win32_NetworkManagement_IpHelper",
"Win32_NetworkManagement_Ndis",
"Win32_Networking_WinSock",
# 手机遥控·P1 系统音量:MMDevice + IAudioEndpointVolume(Endpoints 有独立 feature 门控;
# IMMDevice::Activate 另需 Com_StructuredStorage)
"Win32_Media_Audio",
"Win32_Media_Audio_Endpoints",
"Win32_System_Com_StructuredStorage",
"Security_Cryptography", "Security_Cryptography",
# 划词取词的智能路径:UIA 直读焦点元素选区(IUIAutomation / ITextProvider) # 划词取词的智能路径:UIA 直读焦点元素选区(IUIAutomation / ITextProvider)
"Win32_UI_Accessibility", "Win32_UI_Accessibility",
@@ -0,0 +1,83 @@
//! **临时**端到端验证:对真实 musicex 样本走完整「取密钥 → 解密 → 校验」流程。
//!
//! 用法(需要 QQ 音乐在运行且已登录):
//! ```text
//! cargo run --example decrypt_musicex_probe -- "C:\path\to\file.mflac"
//! ```
//! 验证完即可删除本文件。
use thing_lib::music::decrypt::probe::{probe_musicex, ProbeOutcome};
fn main() {
let mut args = std::env::args().skip(1);
let path = args.next().expect(
"用法:decrypt_musicex_probe <文件路径> [输出目录]\n\
给了输出目录则会用**生产路径**真正写盘(生成可播放文件)",
);
let out_dir = args.next();
match probe_musicex(std::path::Path::new(&path)) {
Ok(ProbeOutcome {
ekey_len,
key_len,
raw_key_bytes,
cipher_magic,
plain_magic,
decrypted_bytes,
guessed_format,
expiration_secs,
}) => {
println!("=== 成功 ===");
println!("ekey 长度 : {ekey_len}");
println!("派生密钥长度 : {key_len}");
println!(
"密钥前 8 字节 : {:02x?}",
&raw_key_bytes[..raw_key_bytes.len().min(8)]
);
println!("密文头 : {:02x?}", cipher_magic);
println!("解密后字节数 : {decrypted_bytes}");
println!("明文首帧魔数 : {:02x?}", plain_magic);
println!("判定格式 : {guessed_format}");
println!("ekey 有效期(秒) : {expiration_secs}");
if guessed_format == "flac" && plain_magic.starts_with(b"fLaC") {
println!("=> 合法 FLAC 头,产物可播");
} else {
println!("=> 头不合法,需要排查");
}
}
Err(e) => {
println!("=== 失败 ===");
println!("{e}");
std::process::exit(1);
}
}
// 可选:调用**生产路径**真正落盘(验证 decrypt_musicex 本身,而不只是核心算法)
if let Some(dir) = out_dir {
println!("\n=== 生产路径落盘 ===");
match thing_lib::music::decrypt::qq_online::decrypt_musicex(
std::path::Path::new(&path),
std::path::Path::new(&dir),
"QQ音乐",
|done, total| {
if done == total {
println!("进度:{done} 字节(完成)");
}
},
) {
Ok(outcome) => {
let size = std::fs::metadata(&outcome.output)
.map(|m| m.len())
.unwrap_or(0);
println!("产物 : {}", outcome.output.display());
println!("大小 : {size} 字节");
println!("格式 : {}", outcome.format);
println!("备注 : {}", outcome.note);
}
Err(e) => {
println!("落盘失败:{e}");
std::process::exit(1);
}
}
}
}
+59
View File
@@ -0,0 +1,59 @@
//! 诊断:枚举全部 GSMTC 会话的时间轴原始值(判断"来源不提供进度"的形态)。
//!
//! 运行:`cargo run --example gsmtc_dump`
use std::time::{SystemTime, UNIX_EPOCH};
use windows::Media::Control::GlobalSystemMediaTransportControlsSessionManager;
fn ticks_to_unix_ms(ticks: i64) -> i64 {
ticks / 10_000 - 62_135_596_800_000
}
fn main() -> windows::core::Result<()> {
let mgr = GlobalSystemMediaTransportControlsSessionManager::RequestAsync()?.get()?;
let sessions = mgr.GetSessions()?;
let now_ms = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_millis() as i64)
.unwrap_or(0);
println!("now(unix ms) = {now_ms}");
println!("sessions = {}", sessions.Size()?);
for i in 0..sessions.Size()? {
let s = sessions.GetAt(i)?;
println!("--- [{}] {}", i, s.SourceAppUserModelId()?);
if let Ok(p) = s.TryGetMediaPropertiesAsync()?.get() {
println!(
" title={:?} artist={:?} album={:?}",
p.Title()?,
p.Artist()?,
p.AlbumTitle()?
);
}
let info = s.GetPlaybackInfo()?;
println!(" status={:?}", info.PlaybackStatus()?);
if let Ok(c) = info.Controls() {
println!(
" controls play={} pause={} next={} prev={} seek={}",
c.IsPlayEnabled().unwrap_or(false),
c.IsPauseEnabled().unwrap_or(false),
c.IsNextEnabled().unwrap_or(false),
c.IsPreviousEnabled().unwrap_or(false),
c.IsPlaybackPositionEnabled().unwrap_or(false)
);
}
let tl = s.GetTimelineProperties()?;
let pos = tl.Position()?.Duration;
let end = tl.EndTime().map(|t| t.Duration).unwrap_or(-1);
let upd = tl.LastUpdatedTime()?.UniversalTime;
let upd_ms = ticks_to_unix_ms(upd);
println!(
" position={}s end={}s lastUpdatedTicks={upd} -> unixMs={upd_ms} (deltaMs={})",
pos as f64 / 1e7,
end as f64 / 1e7,
upd_ms - now_ms
);
}
Ok(())
}
+38
View File
@@ -0,0 +1,38 @@
//! GSMTC 可用性探测(MUSIC_REMOTE_PLAN §7 P0 第 1 项 / §6 第 1 条)
//!
//! 关键假设:GSMTC(Windows.Media.Control)在**非打包**桌面应用可用(Windows 10 1809+)。
//! 本 example 以普通控制台进程运行(无 package identity),跑通即证明假设成立。
//!
//! 运行:`cargo run --example gsmtc_probe`
//! 建议先在任意播放器(网易云/浏览器/Thing)放一首歌,可看到当前会话的元数据与时间轴。
use windows::Media::Control::GlobalSystemMediaTransportControlsSessionManager;
use windows::core::Result;
fn main() -> Result<()> {
// 1. 取全局会话管理器(失败 = 整个能力需降级,见计划 §3.1 失败策略)
let mgr = GlobalSystemMediaTransportControlsSessionManager::RequestAsync()?.get()?;
// 2. 枚举系统全部 SMTC 会话(注意:0.52 投影里 GetSessions/GetCurrentSession 是同步的)
let sessions = mgr.GetSessions()?;
println!("[ok] GSMTC 可用(unpackaged),当前会话数: {}", sessions.Size()?);
// 3. 当前活跃会话的元数据 / 播放状态 / 时间轴
// 无会话时 ABI 返回 null → windows-rs 投影为 Err(E_POINTER),按"无会话"处理
match mgr.GetCurrentSession() {
Ok(cur) => {
println!("current: {}", cur.SourceAppUserModelId()?);
let p = cur.TryGetMediaPropertiesAsync()?.get()?;
println!(" {} - {} | album: {}", p.Artist()?, p.Title()?, p.AlbumTitle()?);
println!(" status: {:?}", cur.GetPlaybackInfo()?.PlaybackStatus()?);
let tl = cur.GetTimelineProperties()?;
println!(
" position(ticks): {} | lastUpdated(ticks): {}",
tl.Position()?.Duration,
tl.LastUpdatedTime()?.UniversalTime
);
}
Err(e) => println!("current session: <none> ({e})(先放一首歌再跑,可看完整元数据)"),
}
Ok(())
}
+41
View File
@@ -0,0 +1,41 @@
//! **临时**校验:用产物解析器确认解密出来的文件是合法音频。
//!
//! 用法:`cargo run --example verify_audio -- <文件路径>`
fn main() {
let path = std::env::args()
.nth(1)
.expect("用法:verify_audio <文件路径>");
let p = std::path::Path::new(&path);
let size = std::fs::metadata(p).map(|m| m.len()).unwrap_or(0);
println!("文件 : {}", p.display());
println!("大小 : {size} 字节");
// 1) 头部魔数
let head = std::fs::read(p).map(|b| b[..16.min(b.len())].to_vec());
match head {
Ok(h) => println!("首帧 : {:02x?}", h),
Err(e) => {
println!("读取失败:{e}");
std::process::exit(1);
}
}
// 2) 交给项目同款的解析器(lofty):能读出时长与格式才算真合法
match lofty::probe::Probe::open(p).and_then(|probe| probe.read()) {
Ok(tagged) => {
use lofty::file::AudioFile;
let props = tagged.properties();
println!("时长 : {:?}", props.duration());
println!("码率 : {:?}", props.audio_bitrate());
println!("采样率 : {:?}", props.sample_rate());
println!("声道 : {:?}", props.channels());
println!("=> lofty 成功解析,文件合法可播");
}
Err(e) => {
println!("lofty 解析失败:{e}");
std::process::exit(1);
}
}
}
+3
View File
@@ -105,6 +105,9 @@ pub mod events {
pub const TERMINAL_SETTINGS: &str = "terminal-settings"; pub const TERMINAL_SETTINGS: &str = "terminal-settings";
// 音乐模块:下载任务事件(桥接事件行 → 前端,负载见 bridge.py _emit_event) // 音乐模块:下载任务事件(桥接事件行 → 前端,负载见 bridge.py _emit_event)
pub const MUSIC_DOWNLOAD_EVENT: &str = "music-download-event"; pub const MUSIC_DOWNLOAD_EVENT: &str = "music-download-event";
// 音乐模块:本地解密任务事件(负载见 music::decrypt::DecryptEvent)
// 与下载链路同构:命令先回 taskId,进度与逐文件结果都走这个事件。
pub const MUSIC_DECRYPT_EVENT: &str = "music-decrypt-event";
// 音乐模块:Rust 侧播放引擎(music/audio)。曲目自然播完(缓冲也放完)后发出,无负载 // 音乐模块:Rust 侧播放引擎(music/audio)。曲目自然播完(缓冲也放完)后发出,无负载
pub const MUSIC_AUDIO_ENDED: &str = "music-audio-ended"; pub const MUSIC_AUDIO_ENDED: &str = "music-audio-ended";
/// 音乐模块:Rust 侧播放失败(音源打不开 / 解码失败 / 输出设备异常),负载为错误文本 /// 音乐模块:Rust 侧播放失败(音源打不开 / 解码失败 / 输出设备异常),负载为错误文本
+31 -3
View File
@@ -7,7 +7,7 @@ mod download_engine;
mod logger; mod logger;
mod mihomo_manager; mod mihomo_manager;
mod monitor_kernel; mod monitor_kernel;
mod music; pub mod music;
mod network_monitor; mod network_monitor;
mod osd_window; mod osd_window;
mod process_manager; mod process_manager;
@@ -58,14 +58,19 @@ use music::{
feiniu_media_prefix, feiniu_save_connection, feiniu_scan_local, feiniu_test_connection, feiniu_media_prefix, feiniu_save_connection, feiniu_scan_local, feiniu_test_connection,
music_audio_play, music_audio_seek, music_audio_set_playing, music_audio_set_volume, music_audio_play, music_audio_seek, music_audio_set_playing, music_audio_set_volume,
music_audio_state, music_audio_stop, music_audio_state, music_audio_stop,
music_cancel_runtime_install, music_download, music_download_cancel, music_env_status, music_cancel_runtime_install, music_decrypt_cancel, music_decrypt_qq_status,
music_decrypt_run, music_decrypt_scan,
music_download, music_download_cancel, music_env_status,
music_get_settings, music_get_sources, music_install_runtime, music_parse_playlist, music_ping, music_get_settings, music_get_sources, music_install_runtime, music_parse_playlist, music_ping,
music_resolve, music_save_settings, music_search, music_secret_get, music_secret_set, music_resolve, music_save_settings, music_search, music_secret_get, music_secret_set,
music_smtc_clear, music_smtc_update_metadata, music_smtc_update_playback_state, music_smtc_clear, music_smtc_update_metadata, music_smtc_update_playback_state,
music_smtc_update_position, music_smtc_update_position,
music_stop_bridge, music_update_musicdl, webdav_delete, webdav_get_secret, music_stop_bridge, music_update_musicdl, webdav_delete, webdav_get_secret,
webdav_save_secret, webdav_test, webdav_save_secret, webdav_test,
webdav_upload, AudioEngine, MusicManager, SmtcController, webdav_upload, remote_cancel_pairing, remote_get_config, remote_list_devices,
remote_publish_queue, remote_revoke_device, remote_set_enabled, remote_start_pairing,
remote_status,
AudioEngine, MusicManager, RemoteManager, SmtcController, SmtcMetaCache,
}; };
use network_monitor::network_status; use network_monitor::network_status;
use osd_window::{ use osd_window::{
@@ -240,6 +245,12 @@ fn export_bindings() {
// music 播放引擎(Rust 侧播放,取代前端 <audio>) // music 播放引擎(Rust 侧播放,取代前端 <audio>)
music_audio_play, music_audio_set_playing, music_audio_seek, music_audio_stop, music_audio_play, music_audio_set_playing, music_audio_seek, music_audio_stop,
music_audio_set_volume, music_audio_state, music_audio_set_volume, music_audio_state,
// music 手机互联(remote,8)
remote_get_config, remote_set_enabled, remote_status, remote_start_pairing,
remote_cancel_pairing, remote_list_devices, remote_revoke_device,
remote_publish_queue,
// music 本地解密(「解密」页签)
music_decrypt_run, music_decrypt_cancel, music_decrypt_scan, music_decrypt_qq_status,
// screenshot(23,豁免 3:get_fullscreen_bmp / take_editor_image_raw 返回 ipc::Response、 // screenshot(23,豁免 3:get_fullscreen_bmp / take_editor_image_raw 返回 ipc::Response、
// compose_copy / compose_png 接收 ipc::Request) // compose_copy / compose_png 接收 ipc::Request)
screenshot_disable_transitions, screenshot_show_overlay, screenshot_register_shortcut, screenshot_disable_transitions, screenshot_show_overlay, screenshot_register_shortcut,
@@ -334,6 +345,10 @@ pub fn run() {
.manage(SmtcController::new()) .manage(SmtcController::new())
// Rust 侧播放引擎(取代前端 <audio>,见 music/audio 模块注释) // Rust 侧播放引擎(取代前端 <audio>,见 music/audio 模块注释)
.manage(AudioEngine::new()) .manage(AudioEngine::new())
// 手机互联:遥控状态容器(MUSIC_REMOTE_PLAN §5.1 平级 manage)+
// SMTC 元数据兜底缓存(remote/glsmtc §5.2 聚合用)
.manage(RemoteManager::new())
.manage(SmtcMetaCache::default())
.invoke_handler(tauri::generate_handler![ .invoke_handler(tauri::generate_handler![
quit_app, quit_app,
app_version, app_version,
@@ -433,6 +448,14 @@ pub fn run() {
music_audio_stop, music_audio_stop,
music_audio_set_volume, music_audio_set_volume,
music_audio_state, music_audio_state,
remote_get_config,
remote_set_enabled,
remote_status,
remote_start_pairing,
remote_cancel_pairing,
remote_list_devices,
remote_revoke_device,
remote_publish_queue,
webdav_test, webdav_test,
webdav_upload, webdav_upload,
webdav_delete, webdav_delete,
@@ -440,6 +463,11 @@ pub fn run() {
webdav_save_secret, webdav_save_secret,
music_secret_get, music_secret_get,
music_secret_set, music_secret_set,
// 音乐模块:本地解密(「解密」页签)
music_decrypt_run,
music_decrypt_cancel,
music_decrypt_scan,
music_decrypt_qq_status,
feiniu_delete_local, feiniu_delete_local,
network_status, network_status,
osd_apply_overlay_style, osd_apply_overlay_style,
+324
View File
@@ -0,0 +1,324 @@
//! 音乐模块 · 本地解密的 Tauri 命令层。
//!
//! 与下载链路同构:命令只做参数校验 + 扫描 + 登记任务,立即返回;进度经
//! `music-decrypt-event` 推送。前端 `decryptStore` 常驻监听。
//!
//! 登记位置见 `MUSIC_DECRYPT_PLAN.md` §4.1——**共 3 处**:
//! `music/mod.rs` re-export、`lib.rs` 的 `collect_commands![]` 与 `generate_handler![]`。
use std::path::{Path, PathBuf};
use tauri::{AppHandle, State};
use super::scan;
use super::spawn_batch;
use crate::music::MusicManager;
/// 启动一批本地解密任务。
///
/// 两种输入方式(二选一,`folder` 优先):
/// - `folder`:**文件夹批量**。递归扫描该目录下所有可解密的加密音乐
/// (内容判定优先,见 `scan::route`),并按 `root` 还原相对目录结构。
/// - `files`:显式文件列表(散选场景)。
///
/// `in_place = true` 时产物与源文件同目录同名——文件夹批量推荐这样用,
/// 符合"就地解出来"的直觉;`false` 则统一输出到 `out_dir`。
///
/// 返回 `Ok(())` 表示任务已登记并开始执行;逐文件结果走事件。
#[tauri::command]
#[specta::specta]
pub fn music_decrypt_run(
state: State<'_, MusicManager>,
app: AppHandle,
task_id: String,
files: Option<Vec<String>>,
folder: Option<String>,
root: Option<String>,
out_dir: Option<String>,
in_place: Option<bool>,
) -> Result<(), String> {
if task_id.trim().is_empty() {
return Err("缺少任务 id".into());
}
let in_place = in_place.unwrap_or(false);
let out_dir = resolve_out_dir(out_dir)?;
// ---- 收集待处理文件 ----
let scanned: Vec<scan::ScannedFile> = match folder.as_deref().map(str::trim) {
Some(dir) if !dir.is_empty() => {
let folder_path = PathBuf::from(dir);
let root_path = root
.as_deref()
.map(str::trim)
.filter(|r| !r.is_empty())
.map(PathBuf::from)
.unwrap_or_else(|| folder_path.clone());
let found = scan::scan(&folder_path, Some(&root_path))?;
if found.is_empty() {
return Err(format!(
"{} 里没有找到可解密的加密音乐文件(支持网易云 .ncm 与 QQ音乐 QMC 系列)",
folder_path.display()
));
}
found
}
_ => {
let list = files.unwrap_or_default();
if list.is_empty() {
return Err("未选择任何文件或文件夹".into());
}
// 散选:保留用户给的路径,不做递归;引擎按内容/后缀判定。
// 认不出的文件也建条目,让 worker 回报 unsupported(用户能看到原因)。
list.into_iter()
.map(|f| {
let path = PathBuf::from(&f);
let name = path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_else(|| f.clone());
// 先算引擎再移动 `path`(否则所有权已转移)
let engine = scan::route(&path).unwrap_or(scan::Engine::Ncm);
scan::ScannedFile {
path,
rel_parent: None,
name,
// 默认为网易云引擎;真实平台由解密器在 worker 内报错说明
engine,
}
})
.collect()
}
};
// ---- 输入输出相交保护(仅非就地模式;就地模式本来就写在源目录)----
let scanned = if in_place {
scanned
} else {
let kept = retain_outside(scanned, &out_dir);
if kept.is_empty() {
return Err("所选文件都位于输出目录内,已全部跳过(可改用「就地解密」)".into());
}
kept
};
if scanned.is_empty() {
return Err("没有可处理的文件".into());
}
let tasks = state.decrypt_tasks();
spawn_batch(app, tasks, task_id, scanned, out_dir, in_place);
Ok(())
}
/// 请求取消一个解密任务。
///
/// 队列级语义(与 `music_download_cancel` 一致):**当前文件会做完**,
/// 剩余文件不再开始处理,随后发一个带 `cancelled` 计数的 `finished` 事件。
/// 返回是否命中了一个在跑的任务(false 通常表示任务已结束)。
#[tauri::command]
#[specta::specta]
pub fn music_decrypt_cancel(
state: State<'_, MusicManager>,
task_id: String,
) -> Result<bool, String> {
Ok(state.decrypt_tasks().cancel(&task_id))
}
/// 扫描一个文件夹,返回可解密文件的数量与平台分布(**不解密**)。
///
/// 给 UI 做预览:用户选完文件夹先看到"找到 N 个(网易云 x / QQ音乐 y)",
/// 而不是直接开跑一个可能包含几千首的任务。
#[tauri::command]
#[specta::specta]
pub fn music_decrypt_scan(folder: String, root: Option<String>) -> Result<ScanSummary, String> {
let root_path = root
.as_deref()
.map(str::trim)
.filter(|r| !r.is_empty())
.map(PathBuf::from);
let found = scan::scan(Path::new(folder.trim()), root_path.as_deref())?;
let ncm = found
.iter()
.filter(|f| f.engine == scan::Engine::Ncm)
.count();
Ok(ScanSummary {
total: found.len(),
ncm,
qmc: found.len() - ncm,
})
}
/// `music_decrypt_scan` 的返回(前端零手写类型)
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
#[serde(rename_all = "camelCase")]
pub struct ScanSummary {
pub total: usize,
pub ncm: usize,
pub qmc: usize,
}
/// 探测 QQ 音乐**在线取密钥**能力(新版 musicex 文件解密的前置条件)。
///
/// 只读本机信息,不发网络请求:读 `QQMusicServiceConfig.ini` 的 `uin`,
/// 再从运行中的 `QQMusic.exe` 内存里找 `authst`。
///
/// `authst` **不会**返回给前端(只在后端用于调接口),前端拿到的只有 QQ 号与状态。
#[tauri::command]
#[specta::specta]
pub fn music_decrypt_qq_status() -> Result<super::qq_online::QqOnlineStatus, String> {
Ok(super::qq_online::probe_status())
}
/// 过滤掉位于 `out_dir` 内的输入文件。
///
/// 为什么需要:把输出目录选在输入目录内(或直接选输入目录)时,下一次运行会把
/// 上一次的产物再当输入解一遍,产出 `_1`、`_2` 无限膨胀。
///
/// 路径比较用 `canonicalize`,因此能正确处理 `..`、大小写差异与短路径;
/// **无法规范化(文件不存在/无权限)的路径一律保留**——让 worker 去报"读取失败",
/// 比在这里静默丢弃更好(用户能看到原因)。
fn retain_outside(files: Vec<scan::ScannedFile>, out_dir: &Path) -> Vec<scan::ScannedFile> {
let Ok(out_canon) = out_dir.canonicalize() else {
// 输出目录都规范化不了(理论上不会:resolve_out_dir 刚创建过它),
// 此时放弃这层保护而不是误杀全部输入
return files;
};
files
.into_iter()
.filter(|f| match f.path.canonicalize() {
Ok(abs) => !abs.starts_with(&out_canon),
Err(_) => true,
})
.collect()
}
/// 解析输出目录:显式传入优先,否则回退到应用数据目录下的 `music/decrypted`。
fn resolve_out_dir(out_dir: Option<String>) -> Result<PathBuf, String> {
if let Some(d) = out_dir {
let d = d.trim();
if !d.is_empty() {
let p = PathBuf::from(d);
std::fs::create_dir_all(&p)
.map_err(|e| format!("无法创建输出目录 {}:{e}", p.display()))?;
return Ok(p);
}
}
// 兜底:{app_data}/music/decrypted(前端正常都会传 savedir/decrypted)
let base = dirs::data_dir()
.ok_or_else(|| "无法定位应用数据目录".to_string())?
.join("thing")
.join("music")
.join("decrypted");
std::fs::create_dir_all(&base)
.map_err(|e| format!("无法创建输出目录 {}:{e}", base.display()))?;
Ok(base)
}
#[cfg(test)]
mod tests {
use super::*;
fn tmpdir(tag: &str) -> PathBuf {
let d = std::env::temp_dir().join(format!("dec_cmd_{tag}_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&d);
std::fs::create_dir_all(&d).unwrap();
d
}
fn fake_ncm() -> Vec<u8> {
let mut v = b"CTENFDAM".to_vec();
v.extend_from_slice(&[0x02, 0x00, 0, 0, 0, 0]);
v
}
fn entry(path: PathBuf, rel: Option<&str>) -> scan::ScannedFile {
scan::ScannedFile {
name: path.file_name().unwrap().to_string_lossy().to_string(),
path,
rel_parent: rel.map(PathBuf::from),
engine: scan::Engine::Ncm,
}
}
#[test]
fn retain_outside_drops_inputs_inside_output_dir() {
let root = tmpdir("retain");
let out = root.join("decrypted");
std::fs::create_dir_all(&out).unwrap();
let inside = out.join("a.ncm");
let outside = root.join("b.ncm");
std::fs::write(&inside, fake_ncm()).unwrap();
std::fs::write(&outside, fake_ncm()).unwrap();
let kept = retain_outside(vec![entry(inside, None), entry(outside, None)], &out);
assert_eq!(kept.len(), 1, "应只保留输出目录外的文件");
assert!(kept[0].path.ends_with("b.ncm"));
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn retain_outside_drops_nested_paths() {
let root = tmpdir("nested");
let out = root.join("decrypted");
let deep = out.join("2026").join("07");
std::fs::create_dir_all(&deep).unwrap();
let f = deep.join("c.ncm");
std::fs::write(&f, fake_ncm()).unwrap();
let kept = retain_outside(vec![entry(f, None)], &out);
assert!(kept.is_empty(), "输出目录的子目录也应视为相交");
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn retain_outside_keeps_unresolvable_paths() {
let root = tmpdir("unresolvable");
let out = root.join("decrypted");
std::fs::create_dir_all(&out).unwrap();
let ghost = root.join("not-here").join("ghost.ncm");
let kept = retain_outside(vec![entry(ghost, None)], &out);
assert_eq!(kept.len(), 1, "不存在的输入不应被静默丢弃");
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn resolve_out_dir_uses_explicit_value() {
let root = tmpdir("outdir");
let target = root.join("my").join("out");
let got = resolve_out_dir(Some(target.to_string_lossy().to_string())).unwrap();
assert_eq!(got, target);
assert!(target.is_dir(), "输出目录应被创建");
let fallback = resolve_out_dir(Some(" ".into())).unwrap();
assert!(fallback.ends_with("decrypted"));
assert!(fallback.is_dir());
let _ = std::fs::remove_dir_all(&root);
}
/// 文件夹扫描的汇总(UI 预览用)
#[test]
fn scan_summary_counts_per_engine() {
let root = tmpdir("summary");
std::fs::write(root.join("a.ncm"), fake_ncm()).unwrap();
std::fs::write(root.join("b.qmcflac"), vec![0x22u8; 4096]).unwrap();
std::fs::write(root.join("c.mgg"), vec![0x22u8; 4096]).unwrap();
std::fs::write(root.join("d.mp3"), vec![0x44u8; 1024]).unwrap();
let found = scan::scan(&root, None).unwrap();
let ncm = found
.iter()
.filter(|f| f.engine == scan::Engine::Ncm)
.count();
assert_eq!(found.len(), 3, "mp3 不应被计入");
assert_eq!(ncm, 1);
assert_eq!(found.len() - ncm, 2);
let _ = std::fs::remove_dir_all(&root);
}
}
+266
View File
@@ -0,0 +1,266 @@
//! 本地解密的**统一错误类型与公共格式探测**。
//!
//! 两个引擎([`super::ncm`] 网易云 / [`super::qmc`] QQ音乐)各自的内部错误不同,
//! 但调度层只关心「可读的中文原因」,因此都收敛到 [`DecryptError`]。
//!
//! 输出扩展名统一由 [`detect_format`] 按**音频首帧魔数**判定——
//! 两个平台都不信任容器里声明的格式字段(详见 `MUSIC_DECRYPT_PLAN.md` §3.1⑥ / §3.2 末)。
use std::fmt;
use std::path::PathBuf;
/// 解密失败原因。全部经 `to_string()` 上报为 per-file 失败,**不 panic**
/// (否则一个坏文件会带走整批任务)。
#[derive(Debug)]
pub enum DecryptError {
Io(String),
/// 文件不属于本引擎认得的加密格式
NotEncrypted(String),
/// 容器/尾部结构残缺
Broken(String),
/// 缺少解密密钥(QQ QMC2 的 ekey 情况),文案要能给用户下一步动作
KeyRequired(String),
/// 输出失败
Output(String),
}
impl fmt::Display for DecryptError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
DecryptError::Io(e) => write!(f, "读取失败:{e}"),
DecryptError::NotEncrypted(e) => write!(f, "{e}"),
DecryptError::Broken(e) => write!(f, "文件结构损坏:{e}"),
DecryptError::KeyRequired(e) => write!(f, "{e}"),
DecryptError::Output(e) => write!(f, "输出失败:{e}"),
}
}
}
impl std::error::Error for DecryptError {}
impl From<std::io::Error> for DecryptError {
fn from(e: std::io::Error) -> Self {
DecryptError::Io(e.to_string())
}
}
pub type Result<T> = std::result::Result<T, DecryptError>;
/// 解密产物(两引擎统一形状)
#[derive(Debug, Clone)]
pub struct Outcome {
pub output: PathBuf,
/// 落盘用的扩展名(由首帧魔数判定)
pub format: String,
/// 单独落盘的封面(没有则为 None)
pub cover: Option<PathBuf>,
/// 音频明文字节数
pub audio_bytes: u64,
/// 给 UI 的一行备注(平台 / 密钥形态 / 元数据摘要)。
///
/// 结构化元数据目前只用来拼这一行——P2 做标签回填时再把 `NcmMeta` 提升到
/// `Outcome` 上,不要提前加一个没人读的字段。
pub note: String,
}
/// 按音频首帧魔数判定输出扩展名。
///
/// **这是权威来源**:ncm 的 `format` 字段、QMC 的输入后缀都只是声明,
/// 不可信(QKKDecrypt 同样以内容探测为准)。
pub fn detect_format(head: &[u8]) -> &'static str {
detect_format_opt(head).unwrap_or("flac")
}
/// 同上,但认不出时返回 `None`(调用方可据此决定是否回退到后缀/声明格式)。
pub fn detect_format_opt(head: &[u8]) -> Option<&'static str> {
let starts = |m: &[u8]| head.len() >= m.len() && &head[..m.len()] == m;
if starts(b"fLaC") {
Some("flac")
} else if starts(b"OggS") {
Some("ogg")
} else if starts(b"ID3") || (head.len() >= 2 && head[0] == 0xFF && head[1] & 0xE0 == 0xE0) {
// ID3 标签,或无标签 MP3 的帧同步字(0xFFEx / 0xFFFx)
Some("mp3")
} else if starts(b"RIFF") && head.len() >= 12 && &head[8..12] == b"WAVE" {
Some("wav")
} else if head.len() >= 12 && &head[4..8] == b"ftyp" {
Some("m4a")
} else if starts(b"wvpk") {
Some("wv")
} else {
None
}
}
/// 图片扩展名(按魔数)
pub fn image_ext(data: &[u8]) -> &'static str {
const PNG: &[u8] = &[0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
if data.len() >= 8 && &data[..8] == PNG {
"png"
} else {
"jpg"
}
}
/// 确保输出目录存在并返回「按相对目录展开后」的目标目录。
///
/// 文件夹批量模式要保留原目录结构(`Pop/a.mflac` → `out/Pop/a.flac`),
/// 否则不同子目录的同名文件会在输出根目录里互相挤兑(虽然去重逻辑会让位成
/// `_1`,但产物与源的对应关系就丢了)。
pub fn ensure_subdir(
dir: &std::path::Path,
rel_parent: Option<&std::path::Path>,
) -> Result<PathBuf> {
let target = match rel_parent {
Some(rel) if !rel.as_os_str().is_empty() => dir.join(rel),
_ => dir.to_path_buf(),
};
std::fs::create_dir_all(&target)?;
Ok(target)
}
/// 在 `dir` 下为 `stem` + `ext` 找一个不冲突的输出路径。
///
/// 不同来源的同名文件若直接扁平落盘会**互相覆盖**,故占用时追加 `_1`/`_2`…
/// `reserved` 是本批次内已占用的名字(磁盘上尚不存在的也算)。
pub fn unique_output(
dir: &std::path::Path,
stem: &str,
ext: &str,
reserved: &mut std::collections::HashSet<String>,
) -> Result<PathBuf> {
let mut candidate = dir.join(format!("{stem}.{ext}"));
let mut n = 1;
loop {
let key = candidate.to_string_lossy().to_lowercase();
if !candidate.exists() && !reserved.contains(&key) {
reserved.insert(key);
return Ok(candidate);
}
candidate = dir.join(format!("{stem}_{n}.{ext}"));
n += 1;
if n > 9999 {
return Err(DecryptError::Output(format!(
"无法为 {stem} 找到不冲突的输出名"
)));
}
}
}
/// 读满 `buf` 或读到 EOF,返回实际字节数。
///
/// 与 `Read::read` 的关键区别:**只有 EOF 才会提前返回**,不会因为底层缓冲的
/// 短读而返回半个块。流密码解密的块边界必须与加密侧严格一致,
/// 否则相位错位、文件中途变噪声(`MUSIC_DECRYPT_PLAN.md` §6.24)。
pub fn read_full(r: &mut impl std::io::Read, buf: &mut [u8]) -> Result<usize> {
let mut filled = 0usize;
while filled < buf.len() {
match r.read(&mut buf[filled..]) {
Ok(0) => break,
Ok(n) => filled += n,
Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
Err(e) => return Err(DecryptError::Io(e.to_string())),
}
}
Ok(filled)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn detect_format_by_magic() {
assert_eq!(detect_format(b"fLaC\x00\x00\x00\x22"), "flac");
assert_eq!(detect_format(b"OggS\x00\x02"), "ogg");
assert_eq!(detect_format(b"ID3\x04\x00"), "mp3");
assert_eq!(detect_format(&[0xFF, 0xFB, 0x90, 0x00]), "mp3");
assert_eq!(detect_format(b"RIFF\x00\x00\x00\x00WAVEfmt "), "wav");
assert_eq!(detect_format(b"\x00\x00\x00\x20ftypM4A "), "m4a");
assert_eq!(detect_format(b"wvpk\x00\x00"), "wv");
assert_eq!(detect_format(b"\x00\x01\x02\x03"), "flac");
}
#[test]
fn image_ext_by_magic() {
assert_eq!(
image_ext(&[0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]),
"png"
);
assert_eq!(image_ext(&[0xFF, 0xD8, 0xFF, 0xE0]), "jpg");
}
#[test]
fn unique_output_appends_suffix_on_collision() {
let dir = std::env::temp_dir().join(format!("dec_unique_{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let mut reserved = std::collections::HashSet::new();
let a = unique_output(&dir, "song", "flac", &mut reserved).unwrap();
assert_eq!(a.file_name().unwrap(), "song.flac");
let b = unique_output(&dir, "song", "flac", &mut reserved).unwrap();
assert_eq!(b.file_name().unwrap(), "song_1.flac");
let c = unique_output(&dir, "song", "mp3", &mut reserved).unwrap();
assert_eq!(c.file_name().unwrap(), "song.mp3");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn ensure_subdir_preserves_relative_structure() {
let root = std::env::temp_dir().join(format!("dec_subdir_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).unwrap();
// 无相对目录 → 输出根
let flat = ensure_subdir(&root, None).unwrap();
assert_eq!(flat, root);
// 有相对目录 → 逐级创建
let nested = ensure_subdir(
&root,
Some(std::path::Path::new("Pop").join("2026").as_path()),
)
.unwrap();
assert!(nested.is_dir());
assert!(nested.ends_with("Pop/2026") || nested.ends_with(r"Pop\2026"));
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn read_full_returns_whole_buffer() {
// 一个每次只吐 3 字节的 reader:read_full 必须凑满整个 buf
struct Drip {
data: Vec<u8>,
pos: usize,
}
impl std::io::Read for Drip {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
if self.pos >= self.data.len() {
return Ok(0);
}
let n = buf.len().min(3).min(self.data.len() - self.pos);
buf[..n].copy_from_slice(&self.data[self.pos..self.pos + n]);
self.pos += n;
Ok(n)
}
}
let src: Vec<u8> = (0..100u8).collect();
let mut r = Drip {
data: src.clone(),
pos: 0,
};
let mut buf = [0u8; 64];
let n = read_full(&mut r, &mut buf).unwrap();
assert_eq!(n, 64, "短读 reader 也必须凑满整块");
assert_eq!(&buf[..], &src[..64]);
// 末尾不足一块时返回实际长度
let n2 = read_full(&mut r, &mut buf).unwrap();
assert_eq!(n2, 36);
let n3 = read_full(&mut r, &mut buf).unwrap();
assert_eq!(n3, 0, "EOF 返回 0");
}
}
+624
View File
@@ -0,0 +1,624 @@
//! 音乐模块 · 本地解密(`music/decrypt/`)。
//!
//! 挂靠音乐模块的「解密」页签,与下载链路同构:命令先回一个 `taskId`,
//! 之后所有进度经 `music-decrypt-event` 推送(前端 `decryptStore` 常驻监听,
//! 页签切换卸载组件也不影响任务)。
//!
//! ## 分工
//!
//! - [`ncm`]:网易云 `.ncm` 的**纯 Rust 离线**引擎(P0 全部范围)。
//! - `qq`(P1,未实施):QQ 音乐三层路由(内嵌 ekey 离线 → musicex API → Frida 兜底)。
//! 见 `MUSIC_DECRYPT_PLAN.md` §3.2。
//! - [`commands`]:Tauri 命令层(run / cancel)。
//!
//! ## 为什么事件在独立线程里发
//!
//! 解密是 CPU + 磁盘密集的同步流程,每读一块就要回报进度。把它放在
//! `spawn_blocking` 里再逐块 `emit` 会阻塞 tokio 的工作线程;
//! 这里改为「`std::thread` 干活 + `mpsc` 回传事件 + 异步任务节流转发」,
//! 读盘线程最多被 `mpsc::send` 短暂挡住,不碰 tokio 运行时。
//!
//! 进度**按时间节流**([`PROGRESS_INTERVAL`]):单个大文件有成千上万个 32KB 块,
//! 不节流会把 WebView 的事件通道打满。
pub mod commands;
pub mod common;
pub mod ncm;
pub mod probe;
pub mod qmc;
pub mod qq_credentials;
pub mod qq_ekey;
pub mod qq_footer;
pub mod qq_online;
pub mod scan;
/// QQ 音乐进程内存扫描:纯 Win32 实现,非 Windows 平台不编译。
#[cfg(windows)]
pub mod qq_memscan;
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{mpsc, Arc, Mutex};
use std::time::{Duration, Instant};
use serde::{Deserialize, Serialize};
use specta::Type;
use tauri::{AppHandle, Emitter};
use common::DecryptError;
/// 进度事件的最小间隔
pub const PROGRESS_INTERVAL: Duration = Duration::from_millis(300);
/// 单文件处理结果的三个状态
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "lowercase")]
pub enum FileStatus {
/// 解密成功
Ok,
/// 失败(`message` 为可读原因)
Error,
/// 该文件不属于本平台/本阶段支持范围
Unsupported,
}
/// 推送给前端的事件负载(与 `src/lib/bindings.ts` / `decryptStore.ts` 对应)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(tag = "type", rename_all = "kebab-case")]
pub enum DecryptEvent {
/// 批次开始,`total` 为待处理文件数
Start { task_id: String, total: usize },
/// 单个文件处理完毕
File {
task_id: String,
/// 0-based 序号,与任务表行一一对应
index: usize,
name: String,
status: FileStatus,
/// 失败原因,或成功时的备注(平台 / 密钥形态)
message: Option<String>,
/// 主产物路径
output: Option<String>,
/// 单独落盘的封面(网易云 ncm 带内嵌封面时才有)
cover: Option<String>,
},
/// 进度(节流后)
Progress {
task_id: String,
done: usize,
total: usize,
/// 当前文件已处理字节数 / 总字节数(0 表示未知)
bytes_done: u64,
bytes_total: u64,
name: String,
},
/// 批次结束
Finished {
task_id: String,
ok: usize,
failed: usize,
/// 被取消时尚未处理的文件数
cancelled: usize,
},
}
/// 任务表条目。只存「是否被要求取消」,不存进度——
/// 进度的权威在前端 store(事件即真相),Rust 侧不需要镜像状态。
pub struct DecryptTasks {
inner: Mutex<HashMap<String, Arc<AtomicBool>>>,
}
impl Default for DecryptTasks {
fn default() -> Self {
Self::new()
}
}
impl DecryptTasks {
pub fn new() -> Self {
Self {
inner: Mutex::new(HashMap::new()),
}
}
/// 登记一个任务并返回它的取消标志
pub fn register(&self, task_id: &str) -> Arc<AtomicBool> {
let flag = Arc::new(AtomicBool::new(false));
if let Ok(mut m) = self.inner.lock() {
m.insert(task_id.to_string(), flag.clone());
}
flag
}
/// 请求取消;返回是否命中了一个在跑的任务
pub fn cancel(&self, task_id: &str) -> bool {
match self.inner.lock() {
Ok(m) => match m.get(task_id) {
Some(flag) => {
flag.store(true, Ordering::SeqCst);
true
}
None => false,
},
Err(_) => false,
}
}
pub fn finish(&self, task_id: &str) {
if let Ok(mut m) = self.inner.lock() {
m.remove(task_id);
}
}
}
/// 线程 → 异步任务的事件通道消息
enum Msg {
Progress {
bytes_done: u64,
bytes_total: u64,
name: String,
},
File {
index: usize,
name: String,
status: FileStatus,
message: Option<String>,
output: Option<String>,
cover: Option<String>,
},
/// 批次结束。**必须走通道**——否则它会在转发线程尚未冲出积压的
/// `File` 事件之前就被 `emit`,前端会先看到"完成"再看到最后几个文件的结果。
Finished {
ok: usize,
failed: usize,
cancelled: usize,
},
}
/// 该文件是否是「需要联网取密钥」的形态(musicex)。
///
/// 只读尾部 192 字节,代价可忽略;用作"离线失败后要不要转在线"的判据,
/// 避免对普通失败(如尾部损坏)也去发起网络请求。
fn needs_online(path: &std::path::Path) -> bool {
use std::io::{Read, Seek, SeekFrom};
let Ok(mut f) = std::fs::File::open(path) else {
return false;
};
let Ok(size) = f.metadata().map(|m| m.len()) else {
return false;
};
let take = (qq_footer::MUSICEX_FOOTER_LEN as u64).min(size) as usize;
if take < 8 || f.seek(SeekFrom::End(-(take as i64))).is_err() {
return false;
}
let mut buf = vec![0u8; take];
if f.read_exact(&mut buf).is_err() {
return false;
}
qq_footer::is_musicex_tail(&buf)
}
/// 启动一个解密批次:登记任务 → 起工作线程 → 异步转发事件。
///
/// 调用方(`commands::music_decrypt_run`)已完成参数校验与目录扫描;本函数只负责调度。
///
/// `in_place = true` 时**忽略 `out_dir`**,产物与源文件同目录同名(扩展名按格式改)。
/// 这是文件夹批量的默认方式——用户的期望是"就地解出来",而不是去另一个目录找。
pub fn spawn_batch(
app: AppHandle,
tasks: Arc<DecryptTasks>,
task_id: String,
files: Vec<scan::ScannedFile>,
out_dir: PathBuf,
in_place: bool,
) {
let flag = tasks.register(&task_id);
let (tx, rx) = mpsc::channel::<Msg>();
let total_files = files.len();
// ---- 工作线程:逐文件解密 ----
let worker_task_id = task_id.clone();
let worker_tasks = tasks.clone();
std::thread::Builder::new()
.name(format!("music-decrypt-{task_id}"))
.spawn(move || {
let total = files.len();
// 批次内已占用的输出名(防同名互相覆盖,见 common::unique_output)
let mut reserved = std::collections::HashSet::new();
let mut ok = 0usize;
let mut failed = 0usize;
let mut cancelled = 0usize;
let mut done = 0usize;
for (index, job) in files.iter().enumerate() {
if flag.load(Ordering::SeqCst) {
cancelled = total - done;
break;
}
// 输出目录:就地模式与源文件同目录;否则按相对目录还原结构
let target_dir = if in_place {
job.path
.parent()
.map(|p| p.to_path_buf())
.unwrap_or_else(|| out_dir.clone())
} else {
common::ensure_subdir(&out_dir, job.rel_parent.as_deref())
.unwrap_or_else(|_| out_dir.clone())
};
// 进度回调:只在文件内部回报,节流交给接收端
let tx_progress = tx.clone();
let name = job.name.clone();
// 「网易云 / QQ音乐」前缀由调度层给出——引擎自己不该知道路由结果
let label = job.engine.label();
let mut progress_cb = |bytes_done: u64, bytes_total: u64| {
let _ = tx_progress.send(Msg::Progress {
bytes_done,
bytes_total,
name: name.clone(),
});
};
let result = match job.engine {
scan::Engine::Ncm => ncm::decrypt_file(
&job.path,
&target_dir,
label,
&mut reserved,
&mut progress_cb,
),
// musicex 的 ekey 不在文件里,离线路径会返回明确的 KeyRequired;
// 命中该形态时改走「本机凭据 → 在线取密钥」。
scan::Engine::Qmc => {
let offline = qmc::decrypt_file(
&job.path,
&target_dir,
label,
&mut reserved,
&mut progress_cb,
);
match offline {
Err(DecryptError::KeyRequired(_)) if needs_online(&job.path) => {
qq_online::decrypt_musicex(
&job.path,
&target_dir,
label,
&mut progress_cb,
)
}
other => other,
}
}
};
done += 1;
match result {
Ok(res) => {
ok += 1;
crate::logger::log_info(
"music-decrypt",
&format!(
"{} → {}({},{} 字节)",
job.path.display(),
res.output.display(),
res.format,
res.audio_bytes
),
);
let _ = tx.send(Msg::File {
index,
name: job.name.clone(),
status: FileStatus::Ok,
// 成功时把备注(平台/密钥形态)与产物一起回报
message: Some(res.note),
output: Some(res.output.to_string_lossy().to_string()),
cover: res.cover.map(|c| c.to_string_lossy().to_string()),
});
}
Err(e) => {
failed += 1;
crate::logger::log_warn(
"music-decrypt",
&format!("{} 解密失败:{e}", job.path.display()),
);
let _ = tx.send(Msg::File {
index,
name: job.name.clone(),
status: FileStatus::Error,
message: Some(e.to_string()),
output: None,
cover: None,
});
}
}
// 文件收尾时必推一次,保证进度条不因节流停在中间
let _ = tx.send(Msg::Progress {
bytes_done: done as u64,
bytes_total: total as u64,
name: job.name.clone(),
});
}
// 通道关闭 → 接收端读完剩余消息后收尾
let _ = tx.send(Msg::Finished {
ok,
failed,
cancelled,
});
drop(tx);
worker_tasks.finish(&worker_task_id);
})
.expect("无法创建解密工作线程");
// ---- 异步转发:节流 + 顺序保证 ----
//
// 语义:
// - `File` 事件(含文件收尾的那次 Progress)**立即转发**,否则结果会看起来卡在末尾。
// - 文件内部的逐块 Progress 只保留最新一条,按 [`PROGRESS_INTERVAL`] 最多发一次,
// 避免单个大文件的成千上万个块把 WebView 事件通道打满。
tauri::async_runtime::spawn(async move {
let mut last_progress: Option<Msg> = None;
let mut last_emit = Instant::now() - PROGRESS_INTERVAL;
let mut current_index = 0usize;
// 批内文件总数:与下面 Start 事件取同一份来源
let current_total = total_files;
// Start 先发:它必须在任何 Progress/File 之前到达,前端据此建行。
let _ = app.emit(
crate::constants::events::MUSIC_DECRYPT_EVENT,
&DecryptEvent::Start {
task_id: task_id.clone(),
total: total_files,
},
);
loop {
// 单次 recv_timeout 同时兼顾「有消息就收」和「到点就 flush」
let msg = match rx.recv_timeout(PROGRESS_INTERVAL) {
Ok(m) => Some(m),
Err(mpsc::RecvTimeoutError::Timeout) => None,
Err(mpsc::RecvTimeoutError::Disconnected) => break,
};
match msg {
Some(Msg::Progress {
bytes_done,
bytes_total,
name,
}) => {
// 攒着;下面的 flush 决定何时真正发出
last_progress = Some(Msg::Progress {
bytes_done,
bytes_total,
name,
});
}
Some(Msg::File {
index,
name,
status,
message,
output,
cover,
}) => {
// 结果事件优先:先把攒住的进度冲掉,再发结果,保证顺序自然
flush_progress(
&app,
&task_id,
&mut last_progress,
&mut last_emit,
current_index,
current_total,
);
let _ = app.emit(
crate::constants::events::MUSIC_DECRYPT_EVENT,
&DecryptEvent::File {
task_id: task_id.clone(),
index,
name,
status,
message,
output,
cover,
},
);
current_index = index + 1;
}
Some(Msg::Finished {
ok,
failed,
cancelled,
}) => {
// 收尾前把攒住的进度冲掉,再发 Finished,保证前端不丢最后一格进度
last_emit = Instant::now() - PROGRESS_INTERVAL;
flush_progress(
&app,
&task_id,
&mut last_progress,
&mut last_emit,
current_index,
current_total,
);
let _ = app.emit(
crate::constants::events::MUSIC_DECRYPT_EVENT,
&DecryptEvent::Finished {
task_id: task_id.clone(),
ok,
failed,
cancelled,
},
);
// 通道随后关闭,循环自然退出
}
None => { /* 超时,走下面的 flush */ }
}
flush_progress(
&app,
&task_id,
&mut last_progress,
&mut last_emit,
current_index,
current_total,
);
}
});
}
/// 到点则把攒下的最新一条进度发出(最多每 [`PROGRESS_INTERVAL`] 一次)。
fn flush_progress(
app: &AppHandle,
task_id: &str,
pending: &mut Option<Msg>,
last_emit: &mut Instant,
index: usize,
total: usize,
) {
if pending.is_none() || last_emit.elapsed() < PROGRESS_INTERVAL {
return;
}
if let Some(Msg::Progress {
bytes_done,
bytes_total,
name,
}) = pending.take()
{
*last_emit = Instant::now();
let _ = app.emit(
crate::constants::events::MUSIC_DECRYPT_EVENT,
&DecryptEvent::Progress {
task_id: task_id.to_string(),
// index = 当前正在处理的文件序号(已完成的文件数)
done: index,
total,
bytes_done,
bytes_total,
name,
},
);
}
}
#[cfg(test)]
mod tests {
use super::*;
/// **跨端契约**:事件的实际 JSON 形状是前端 `decryptStore.ts` 里 `RawEvent`
/// 的镜像。曾经打算写 camelCase(`taskId`),但枚举上只有 `tag` 带了
/// `rename_all`,**字段名仍是 snake_case**——两边不一致时不会编译报错,
/// 只会表现为「任务建好了但进度永远不动」。这个测试把形状钉死。
#[test]
fn event_json_contract() {
let start = serde_json::to_value(DecryptEvent::Start {
task_id: "t1".into(),
total: 3,
})
.unwrap();
assert_eq!(
start,
serde_json::json!({ "type": "start", "task_id": "t1", "total": 3 })
);
let file = serde_json::to_value(DecryptEvent::File {
task_id: "t1".into(),
index: 2,
name: "a.ncm".into(),
status: FileStatus::Error,
message: Some("坏了".into()),
output: None,
cover: None,
})
.unwrap();
assert_eq!(
file,
serde_json::json!({
"type": "file", "task_id": "t1", "index": 2, "name": "a.ncm",
"status": "error", "message": "坏了", "output": null, "cover": null
})
);
let progress = serde_json::to_value(DecryptEvent::Progress {
task_id: "t1".into(),
done: 1,
total: 3,
bytes_done: 10,
bytes_total: 100,
name: "a.ncm".into(),
})
.unwrap();
assert_eq!(
progress,
serde_json::json!({
"type": "progress", "task_id": "t1", "done": 1, "total": 3,
"bytes_done": 10, "bytes_total": 100, "name": "a.ncm"
})
);
let finished = serde_json::to_value(DecryptEvent::Finished {
task_id: "t1".into(),
ok: 2,
failed: 1,
cancelled: 0,
})
.unwrap();
assert_eq!(
finished,
serde_json::json!({
"type": "finished", "task_id": "t1", "ok": 2, "failed": 1, "cancelled": 0
})
);
}
/// `FileStatus` 的三个取值必须是前端 `DecryptFileStatus` 认得的字面量
#[test]
fn file_status_variants_are_lowercase() {
let j = |s| serde_json::to_string(&s).unwrap();
assert_eq!(j(FileStatus::Ok), "\"ok\"");
assert_eq!(j(FileStatus::Error), "\"error\"");
assert_eq!(j(FileStatus::Unsupported), "\"unsupported\"");
}
/// 平台路由见 `scan::route`(内容优先于后缀)——这里只验证单测覆盖到的路径。
#[test]
fn engine_route_by_content_and_extension() {
use scan::Engine;
let dir = std::env::temp_dir().join(format!("dec_route_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
// 网易云:只看魔数,后缀随便
let ncm = dir.join("x.bin");
let mut bytes = b"CTENFDAM".to_vec();
bytes.extend_from_slice(&[0x02, 0x00, 0, 0, 0, 0]);
std::fs::write(&ncm, &bytes).unwrap();
assert_eq!(scan::route(&ncm), Some(Engine::Ncm));
// QQ:后缀在家族里
let qmc = dir.join("y.qmcflac");
std::fs::write(&qmc, vec![0x22u8; 4096]).unwrap();
assert_eq!(scan::route(&qmc), Some(Engine::Qmc));
// 普通音频文件不应被认领
let mp3 = dir.join("z.mp3");
std::fs::write(&mp3, vec![0x44u8; 4096]).unwrap();
assert_eq!(scan::route(&mp3), None);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn task_registry_register_cancel_finish() {
let tasks = DecryptTasks::new();
let flag = tasks.register("t1");
assert!(!flag.load(Ordering::SeqCst));
// 取消命中
assert!(tasks.cancel("t1"));
assert!(flag.load(Ordering::SeqCst));
// 未登记的任务取消不报错、返回 false
assert!(!tasks.cancel("nope"));
tasks.finish("t1");
assert!(!tasks.cancel("t1"), "已结束的任务不应再被取消");
}
}
+734
View File
@@ -0,0 +1,734 @@
//! 网易云音乐 `.ncm` 离线解密引擎(纯 Rust,无外部依赖、无运行时前置)。
//!
//! 算法对照 **MIT 协议** 的 `taurusxin/ncmdump`(`src/ncmcrypt.cpp`)独立重写。
//! 下面每个常量与分支都对应容器里的一个实际字段,注释里标了「为什么」——
//! 这几处正是最容易写错的地方,改动前请先读 `MUSIC_DECRYPT_PLAN.md` §3.1。
//!
//! ## 容器结构
//!
//! ```text
//! 0x00 magic 8B "CTENFDAM"
//! 0x08 2B 固定跳过
//! 0x0A key_len 4B LE
//! key_data XOR 0x64 → AES-128-ECB → 跳 17B → RC4 密钥盒种子
//! meta_len 4B LE
//! meta_data XOR 0x63 → 去 22B 前缀 → base64 → AES-128-ECB → 去 6B 前缀 → JSON
//! 5B 固定跳过(CRC32 4B + 图片版本 1B)
//! cover_len 4B LE / img_len 4B LE / img_data → 跳 cover_len - img_len
//! audio 剩余全部(RC4 变体,按 0x8000 分块)
//! ```
//!
//! 两段 XOR 常量不同(`0x64` / `0x63`)、AES 收尾是 PKCS#7 风格 padding、
//! 密钥盒 KSA 带 `last_byte` 累加——任一写错都会全量解错,
//! 且不会报错,只会产出乱码音频。
use std::fs::File;
use std::io::{BufReader, BufWriter, Read, Write};
use std::path::Path;
use aes::cipher::generic_array::GenericArray;
use aes::cipher::{BlockDecrypt, KeyInit};
use aes::Aes128;
use super::common::{self, DecryptError};
/// 头部魔数(ASCII `CTENFDAM`)
const MAGIC: &[u8; 8] = b"CTENFDAM";
/// key 段的 XOR 常量
const XOR_KEY: u8 = 0x64;
/// meta 段的 XOR 常量(**与 key 段不同**)
const XOR_META: u8 = 0x63;
/// key 段解密后需跳过的前缀:ASCII `neteasecloudmusic`(17 字节,含结尾 NUL)
const CORE_KEY: &[u8; 17] = b"neteasecloudmusic";
/// key 段 **AES 密钥**:ASCII `neteasecloudmusi`——`CORE_KEY` 的前 16 字节。
///
/// 注意与上面 17 字节的「前缀」区分:前缀(`neteasecloudmusic\0`,17B)是解密后
/// 要从明文里剥掉的,AES 密钥(16B)是用来解密的。`aes::Aes128` 只吃 16 字节。
const CORE_AES_KEY: &[u8; 16] = b"neteasecloudmusi";
/// meta 段 AES 密钥:ASCII `#14ljk_!\]&0U<'(`(**与 CORE_KEY 不同**,别复用)
///
/// 注意是 16 字节而非 17——`aes::Aes128` 的密钥长度就是 16。
const MODIFY_KEY: &[u8; 16] = b"#14ljk_!\\]&0U<'(";
/// meta 段 base64 之前的字面量前缀
const META_PREFIX: &[u8] = b"163 key(Don't modify):";
/// meta 段 AES 解密后的字面量前缀
const META_JSON_PREFIX: &[u8] = b"music:";
/// 音频段分块大小。**块之间不额外跳字节**——这个值只是读写块大小。
const CHUNK: usize = 0x8000;
/// ncm 内嵌元数据(meta 段 JSON 的子集)
#[derive(Debug, Clone, Default)]
pub struct NcmMeta {
pub name: Option<String>,
pub artist: Option<String>,
pub album: Option<String>,
pub bitrate: Option<u64>,
pub duration: Option<u64>,
/// 容器内声明的格式。**不用于决定输出扩展名**(那只认音频首帧魔数)。
pub format: Option<String>,
}
/// 本模块的错误类型 = 公共错误类型([`DecryptError`]),
/// 便于调度层对两个引擎用同一套 `?` 与文案处理。
pub type NcmError = DecryptError;
type Result<T> = std::result::Result<T, DecryptError>;
/// AES-128-ECB 解密 + PKCS#7 风格去 padding。
///
/// `aes` crate 只提供块原语(且本项目依赖树里**没有** `ecb` crate),
/// 故这里手写块循环。收尾不是「去前缀」而是取最后一字节当 padding 长度——
/// 这一点在 `MUSIC_DECRYPT_PLAN.md` §3.1③ 有说明。
fn aes_ecb_decrypt(key: &[u8], data: &[u8]) -> Result<Vec<u8>> {
if key.len() != 16 {
return Err(NcmError::Broken(format!(
"AES 密钥长度应为 16,实为 {}",
key.len()
)));
}
if data.is_empty() || data.len() % 16 != 0 {
return Err(NcmError::Broken(format!(
"AES 密文长度 {} 不是 16 的正整数倍",
data.len()
)));
}
let cipher = Aes128::new(GenericArray::from_slice(key));
let blocks = data.len() / 16;
let mut out = Vec::with_capacity(data.len());
let mut buf = [0u8; 16];
for i in 0..blocks {
let block = GenericArray::from_slice(&data[i * 16..i * 16 + 16]);
cipher.decrypt_block_b2b(block, GenericArray::from_mut_slice(&mut buf));
// 最后一块按 padding 截断:末字节即填充长度,>16 视为无填充
if i == blocks - 1 {
let pad = if buf[15] > 16 { 0 } else { buf[15] as usize };
out.extend_from_slice(&buf[..16 - pad.min(16)]);
} else {
out.extend_from_slice(&buf);
}
}
Ok(out)
}
/// 密钥盒构造(KSA)。
///
/// 对照 `ncmdump` `src/ncmcrypt.cpp::buildKeyBox`——**单循环**,但每轮多累加一个
/// `last_byte`(上一轮的 `c`):
///
/// ```text
/// c = (swap + last_byte + key[key_offset]) & 0xff
/// ```
///
/// 这个式子在模 256 下恰好化简为标准 RC4(实测两者密钥盒逐字节相同),
/// 所以**它既不是「关键差异」,也不能靠与标准 RC4 比对来验证**——
/// 验证只能靠固定向量,见单测 `key_box_matches_reference_vectors`。
/// `key_offset` 触 keyLen 归零——即循环取 key。
fn build_key_box(key: &[u8]) -> [u8; 256] {
let mut key_box = [0u8; 256];
for (i, b) in key_box.iter_mut().enumerate() {
*b = i as u8;
}
if key.is_empty() {
return key_box;
}
let mut last_byte: u8 = 0;
let mut key_offset = 0usize;
for i in 0..256usize {
let swap = key_box[i];
let c = swap.wrapping_add(last_byte).wrapping_add(key[key_offset]);
key_offset += 1;
if key_offset >= key.len() {
key_offset = 0;
}
key_box[i] = key_box[c as usize];
key_box[c as usize] = swap;
last_byte = c;
}
key_box
}
/// 原地解密一个音频块。
///
/// 对照 `ncmdump` `src/ncmcrypt.cpp::Dump`——`i` 是**块内下标**,`j = (i + 1) & 0xff`:
///
/// ```text
/// buf[i] ^= mKeyBox[(mKeyBox[j] + mKeyBox[(mKeyBox[j] + j) & 0xff]) & 0xff];
/// ```
///
/// 块与块之间不重置密钥盒、也不额外跳字节(`0x8000` 只是块大小)。
/// 该式只依赖 `i` 与密钥盒,故分块与整体解密结果一致(见单测)。
fn decrypt_audio_chunk(key_box: &[u8; 256], buf: &mut [u8]) {
for i in 0..buf.len() {
let j = (i + 1) & 0xff;
let k = key_box
[key_box[j].wrapping_add(key_box[key_box[j].wrapping_add(j as u8) as usize]) as usize];
buf[i] ^= k;
}
}
/// 封面/标签用的图片扩展名(按魔数,不按 ncm 的说法)
fn image_ext(data: &[u8]) -> &'static str {
common::image_ext(data)
}
/// 读满一块(短读不算块边界)——实现见 [`common::read_full`]。
fn read_full(r: &mut impl Read, buf: &mut [u8]) -> Result<usize> {
common::read_full(r, buf)
}
fn read_u32(r: &mut impl Read) -> Result<u32> {
let mut b = [0u8; 4];
r.read_exact(&mut b)
.map_err(|_| NcmError::Broken("读取长度字段时提前结束".into()))?;
Ok(u32::from_le_bytes(b))
}
fn read_n(r: &mut impl Read, n: usize) -> Result<Vec<u8>> {
let mut buf = vec![0u8; n];
r.read_exact(&mut buf)
.map_err(|_| NcmError::Broken(format!("读取 {n} 字节时提前结束")))?;
Ok(buf)
}
/// 解析 meta JSON 为 `NcmMeta`。
///
/// `artist` 是二维数组(`[["名字", id], ...]`),取每项第 0 个元素并用 `/` 连接。
fn parse_meta(json: &str) -> NcmMeta {
let Ok(v) = serde_json::from_str::<serde_json::Value>(json) else {
return NcmMeta::default();
};
let s = |k: &str| v.get(k).and_then(|x| x.as_str()).map(|x| x.to_string());
let n = |k: &str| v.get(k).and_then(|x| x.as_u64());
let artist = v.get("artist").and_then(|a| a.as_array()).map(|arr| {
arr.iter()
.filter_map(|item| {
item.as_array()
.and_then(|inner| inner.first())
.and_then(|name| name.as_str())
})
.collect::<Vec<_>>()
.join("/")
});
NcmMeta {
name: s("musicName"),
artist: artist.filter(|a| !a.is_empty()),
album: s("album"),
bitrate: n("bitrate"),
duration: n("duration"),
format: s("format"),
}
}
/// 解析头部 + key 段 + meta 段 + 封面,返回 (密钥盒, meta, 封面字节)。
fn read_header(r: &mut impl Read) -> Result<([u8; 256], NcmMeta, Option<Vec<u8>>)> {
// 0x00 magic 8B
let magic = read_n(r, 8)?;
if &magic != MAGIC {
return Err(NcmError::NotEncrypted(
"不是网易云加密文件(头部魔数不是 CTENFDAM)".into(),
));
}
// 0x08 固定 2 字节(读取权重仅为推进游标)
let _ = read_n(r, 2)?;
// ---- key 段 ----
let key_len = read_u32(r)? as usize;
if key_len == 0 {
return Err(NcmError::Broken("key 段长度为 0".into()));
}
let mut key_data = read_n(r, key_len)?;
for b in key_data.iter_mut() {
*b ^= XOR_KEY;
}
let key_plain = aes_ecb_decrypt(CORE_AES_KEY, &key_data)?;
if key_plain.len() <= CORE_KEY.len() {
return Err(NcmError::Broken(format!(
"key 段解密后仅 {} 字节,不足以剥离前缀",
key_plain.len()
)));
}
// 剥离 "neteasecloudmusic\0" 前缀,其余即密钥盒种子
let rc4_key = &key_plain[CORE_KEY.len()..];
let key_box = build_key_box(rc4_key);
// ---- meta 段 ----
let meta_len = read_u32(r)? as usize;
let mut meta = NcmMeta::default();
if meta_len > 0 {
let mut meta_data = read_n(r, meta_len)?;
for b in meta_data.iter_mut() {
*b ^= XOR_META;
}
// 第一层前缀:literal,先剥掉再 base64
if meta_data.len() > META_PREFIX.len() {
let body = &meta_data[META_PREFIX.len()..];
use base64::Engine;
if let Ok(decoded) = base64::engine::general_purpose::STANDARD.decode(body) {
if let Ok(plain) = aes_ecb_decrypt(MODIFY_KEY, &decoded) {
// 第二层前缀:"music:"
let json = if plain.len() > META_JSON_PREFIX.len() {
&plain[META_JSON_PREFIX.len()..]
} else {
&plain[..]
};
// 元数据非 UTF-8 或非 JSON 都不致命:放弃标签即可
if let Ok(s) = std::str::from_utf8(json) {
meta = parse_meta(s);
}
}
}
}
}
// ---- 封面段 ----
// 跳 5 字节:CRC32(4) + 图片版本(1)
let mut five = [0u8; 5];
r.read_exact(&mut five)
.map_err(|_| NcmError::Broken("读取 CRC32/图片版本时提前结束".into()))?;
let cover_frame_len = read_u32(r)? as usize;
let img_len = read_u32(r)? as usize;
let cover = if img_len > 0 {
Some(read_n(r, img_len)?)
} else {
None
};
// 跳到 key 帧末尾
if cover_frame_len > img_len {
let mut discard = vec![0u8; cover_frame_len - img_len];
let _ = r.read_exact(&mut discard);
}
Ok((key_box, meta, cover))
}
/// 判断文件是否为网易云 `.ncm`(只读 8 字节魔数)。
pub fn sniff(path: &Path) -> bool {
let Ok(mut f) = File::open(path) else {
return false;
};
let mut magic = [0u8; 8];
std::io::Read::read_exact(&mut f, &mut magic).is_ok() && &magic == MAGIC
}
/// 解密一个 `.ncm` 文件到 `out_dir`,返回产物信息。
///
/// `progress` 每处理一块回调一次(已处理字节数,总字节数),供上层节流后推事件。
/// `platform_label` 由调度层给出(如「网易云」),用于产物备注。
pub fn decrypt_file<F>(
input: &Path,
out_dir: &Path,
platform_label: &str,
reserved: &mut std::collections::HashSet<String>,
mut progress: F,
) -> Result<common::Outcome>
where
F: FnMut(u64, u64),
{
let total = std::fs::metadata(input).map(|m| m.len()).unwrap_or(0);
let file = File::open(input)?;
let mut reader = BufReader::with_capacity(CHUNK, file);
let (key_box, meta, cover) = read_header(&mut reader)?;
std::fs::create_dir_all(out_dir)?;
// 先写临时文件:格式要等第一块解出来才知道,而输出名又依赖格式。
// 定稿后再 rename —— 中途失败不会留下半个音频冒充成品。
let tmp = out_dir.join(format!(
".dec_part_{}_{}.tmp",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0)
));
let mut buf = vec![0u8; CHUNK];
let mut done: u64 = 0;
let mut format: Option<&'static str> = None;
let mut audio_bytes: u64 = 0;
let write_result = (|| -> Result<()> {
let out = File::create(&tmp)?;
let mut writer = BufWriter::with_capacity(CHUNK, out);
loop {
// **必须读满一个块**(或读到 EOF),不能用 `read` 的短读结果当块边界。
// 解密式依赖「块内偏移 i」,块边界一漂移密钥盒相位就错位——
// 表现为文件从中间某处起全是噪声、前面对得上,极难排查(§6.24)。
let n = read_full(&mut reader, &mut buf)?;
if n == 0 {
break;
}
decrypt_audio_chunk(&key_box, &mut buf[..n]);
if format.is_none() {
format = Some(common::detect_format(&buf[..n]));
}
writer.write_all(&buf[..n])?;
done += n as u64;
audio_bytes += n as u64;
progress(done, total);
}
writer.flush()?;
Ok(())
})();
if let Err(e) = write_result {
let _ = std::fs::remove_file(&tmp);
return Err(e);
}
let format = format.ok_or_else(|| {
let _ = std::fs::remove_file(&tmp);
NcmError::Broken("音频段为空".into())
})?;
let stem = input
.file_stem()
.map(|s| s.to_string_lossy().to_string())
.unwrap_or_else(|| "output".to_string());
let target = common::unique_output(out_dir, &stem, format, reserved)?;
std::fs::rename(&tmp, &target).map_err(|e| {
let _ = std::fs::remove_file(&tmp);
NcmError::Output(format!("重命名产物失败:{e}"))
})?;
// 封面单独落盘(标签回填留 P2:需要 lofty 且要按容器分派)
let cover_path = match cover {
Some(data) if !data.is_empty() => {
let ext = image_ext(&data);
let path = common::unique_output(out_dir, &format!("{stem}.cover"), ext, reserved)?;
std::fs::write(&path, &data)?;
Some(path)
}
_ => None,
};
// 标签信息汇总成一行备注(P2 回填标签前,这是元数据唯一的出口)
let mut note = format!("{platform_label} ncm");
if let Some(n) = meta.name.as_deref() {
note.push_str(&format!(" · {n}"));
}
if let Some(a) = meta.artist.as_deref() {
note.push_str(&format!(" - {a}"));
}
// 位率/时长/专辑:解析成本已经付过,顺手带进备注(也避免字段闲置)
let mut bits: Vec<String> = Vec::new();
if let Some(b) = meta.bitrate {
if b > 0 {
bits.push(format!("{} kbps", b / 1000));
}
}
if let Some(d) = meta.duration {
if d > 0 {
let secs = d / 1000;
bits.push(format!("{}:{:02}", secs / 60, secs % 60));
}
}
if let Some(al) = meta.album.as_deref() {
bits.push(format!("专辑《{al}》"));
}
if let Some(f) = meta.format.as_deref() {
bits.push(format!("声明格式 {f}"));
}
if !bits.is_empty() {
note.push_str(&format!("({})", bits.join(" · ")));
}
Ok(common::Outcome {
output: target,
format: format.to_string(),
cover: cover_path,
audio_bytes,
note,
})
}
#[cfg(test)]
mod tests {
use super::*;
use aes::cipher::BlockEncrypt;
const ZERO_KEY: [u8; 16] = [0u8; 16];
/// AES 正向加密(测试用),与 `aes_ecb_decrypt` 互逆。
fn aes_ecb_encrypt(key: &[u8; 16], data: &[u8]) -> Vec<u8> {
let cipher = Aes128::new(GenericArray::from_slice(key));
let mut out = Vec::with_capacity(data.len());
let mut buf = [0u8; 16];
for chunk in data.chunks(16) {
let block = GenericArray::from_slice(chunk);
cipher.encrypt_block_b2b(block, GenericArray::from_mut_slice(&mut buf));
out.extend_from_slice(&buf);
}
out
}
fn pkcs7_pad(data: &[u8]) -> Vec<u8> {
let pad = 16 - (data.len() % 16);
let mut out = data.to_vec();
out.extend(std::iter::repeat(pad as u8).take(pad));
out
}
#[test]
fn aes_ecb_roundtrip_with_pkcs7() {
let plain = b"CTENFDAM-test-payload-1234";
let padded = pkcs7_pad(plain);
assert_eq!(padded.len() % 16, 0);
let enc = aes_ecb_encrypt(&ZERO_KEY, &padded);
let dec = aes_ecb_decrypt(&ZERO_KEY, &enc).expect("decrypt");
assert_eq!(dec, plain);
}
#[test]
fn aes_ecb_rejects_non_block_multiple() {
assert!(aes_ecb_decrypt(&ZERO_KEY, &[0u8; 17]).is_err());
assert!(aes_ecb_decrypt(&ZERO_KEY, &[]).is_err());
}
/// 空 key 时密钥盒必须是恒等置换(KSA 的边界行为)
#[test]
fn key_box_identity_for_empty_key() {
let kb = build_key_box(&[]);
for i in 0..256 {
assert_eq!(kb[i], i as u8);
}
}
/// 已知答案向量:由参考实现(`ncmdump` 的 `buildKeyBox`)独立算出的值。
///
/// 注意**不能**用「与标准 RC4 比对」来验证——`last_byte` 在模 256 下是恒等变形,
/// 两者逐字节相同。只能靠固定向量锁行为。
#[test]
fn key_box_matches_reference_vectors() {
let kb = build_key_box(b"0123456789abcdef");
assert_eq!(
&kb[..8],
&[0x88, 0x62, 0x96, 0xcc, 0x79, 0x85, 0x7a, 0x21],
"密钥盒前 8 字节与参考实现不符"
);
assert_eq!(
&kb[8..16],
&[0x15, 0x49, 0xa5, 0x91, 0x3d, 0xc6, 0x65, 0xda],
"密钥盒第 8..16 字节与参考实现不符"
);
}
/// 已知答案向量:全零明文的密钥流(即 PRGA 输出)前 24 字节。
#[test]
fn keystream_matches_reference_vector() {
let kb = build_key_box(b"0123456789abcdef");
let mut data = [0u8; 24];
decrypt_audio_chunk(&kb, &mut data);
assert_eq!(
data,
[
0x1d, 0xaf, 0xd7, 0x79, 0xfa, 0xce, 0x0c, 0x2b, 0xab, 0xc4, 0x8c, 0xeb, 0x0d, 0xc3,
0x6a, 0x5c, 0xc6, 0x07, 0x79, 0x63, 0x92, 0x72, 0x69, 0x1b
],
"密钥流与参考实现不符"
);
}
/// 密钥必须循环取用满 256 轮:`key_offset` 归零逻辑要正确。
#[test]
fn key_box_cycles_key_correctly() {
let a = vec![7u8; 300];
let mut b = vec![7u8; 300];
b[250] = 8;
assert_ne!(
build_key_box(&a),
build_key_box(&b),
"密钥第 250 字节未参与运算——key_offset 取模有误"
);
// 短密钥(1 字节)也不能 panic,且是合法置换
let kb = build_key_box(&[0x42]);
let mut seen = [false; 256];
for &x in kb.iter() {
seen[x as usize] = true;
}
assert!(seen.iter().all(|&v| v));
}
/// 加密→解密往返:验证 `decrypt_audio_chunk` 与自身一致,
/// 且块边界不改变结果(`i` 是块内下标这一设计的关键性质)。
#[test]
fn audio_chunk_roundtrip_and_block_boundary_invariance() {
let kb = build_key_box(b"0123456789abcdef");
let plain: Vec<u8> = (0..(CHUNK + 777)).map(|i| (i % 251) as u8).collect();
let mut whole = plain.clone();
decrypt_audio_chunk(&kb, &mut whole);
assert_ne!(whole, plain, "解密未改变数据,密钥盒或 XOR 有误");
let mut chunked = plain.clone();
for c in chunked.chunks_mut(CHUNK) {
decrypt_audio_chunk(&kb, c);
}
assert_eq!(chunked, whole, "分块解密与整体解密结果不一致");
decrypt_audio_chunk(&kb, &mut chunked);
assert_eq!(chunked, plain);
}
#[test]
fn parse_meta_reads_nested_artist() {
let json = r#"{"musicName":"歌","album":"专辑","bitrate":999000,
"duration":215000,"format":"flac",
"artist":[["歌手甲",1],["歌手乙",2]]}"#;
let m = parse_meta(json);
assert_eq!(m.name.as_deref(), Some("歌"));
assert_eq!(m.album.as_deref(), Some("专辑"));
assert_eq!(m.artist.as_deref(), Some("歌手甲/歌手乙"));
assert_eq!(m.bitrate, Some(999000));
assert_eq!(m.duration, Some(215000));
assert_eq!(m.format.as_deref(), Some("flac"));
}
#[test]
fn parse_meta_tolerates_garbage() {
let m = parse_meta("not json at all");
assert!(m.name.is_none() && m.artist.is_none());
}
#[test]
fn not_ncm_file_is_rejected() {
let dir = std::env::temp_dir().join(format!("ncm_bad_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let p = dir.join("fake.ncm");
std::fs::write(&p, b"NOTNCM!!\x02\x00\x00\x00\x00").unwrap();
let mut reserved = std::collections::HashSet::new();
let err = decrypt_file(&p, &dir, "网易云", &mut reserved, |_, _| {}).unwrap_err();
assert!(
matches!(err, NcmError::NotEncrypted(_)),
"期望 NotEncrypted,实得 {err:?}"
);
assert!(!sniff(&p), "魔数不符的文件 sniff 应为 false");
let _ = std::fs::remove_dir_all(&dir);
}
/// **正向构造**一个合法 ncm 容器,再解回来。
/// 这样无需把真实音乐样本(体积大、有版权)放进仓库,仍能覆盖:
/// 两段 XOR 常量、两层 meta 前缀、封面段偏移、分块解密、魔数定格式、输出命名。
#[test]
fn synthetic_ncm_roundtrip() {
let dir = std::env::temp_dir().join(format!("ncm_rt_{}", std::process::id()));
let out = dir.join("out");
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
// 与密钥盒用例共用的固定种子
let seed: &[u8] = b"0123456789abcdef";
// 音频明文:以 fLaC 开头,长度跨块边界多一点
let mut plain = b"fLaC".to_vec();
plain.extend((0..(CHUNK + 123)).map(|i| (i % 253) as u8));
// 用它"加密"音频(XOR 自逆)。加密必须与解密用同样的块大小,
// 否则 PRGA 相位错位(这正是 read_full 存在的原因)。
let kb = build_key_box(seed);
let mut cipher_audio = plain.clone();
for c in cipher_audio.chunks_mut(CHUNK) {
decrypt_audio_chunk(&kb, c);
}
// key 段:**必须**是 CORE_KEY 前缀 + 种子——解密端会剥掉这 17 字节前缀,
// 少了它就会拿到错误的种子。
let mut key_plain = CORE_KEY.to_vec();
key_plain.extend_from_slice(seed);
let mut key_seg = aes_ecb_encrypt(CORE_AES_KEY, &pkcs7_pad(&key_plain));
for b in key_seg.iter_mut() {
*b ^= XOR_KEY;
}
// meta 段:META_PREFIX + base64(AES(META_JSON_PREFIX + json)),再 XOR 0x63
let json = r#"{"musicName":"合成曲","album":"合成专辑","bitrate":320000,"duration":1000,"format":"flac","artist":[["测试歌手",1]]}"#;
let mut meta_plain = META_JSON_PREFIX.to_vec();
meta_plain.extend_from_slice(json.as_bytes());
let meta_enc = aes_ecb_encrypt(MODIFY_KEY, &pkcs7_pad(&meta_plain));
use base64::Engine;
let meta_b64 = base64::engine::general_purpose::STANDARD.encode(&meta_enc);
let mut meta_seg = META_PREFIX.to_vec();
meta_seg.extend_from_slice(meta_b64.as_bytes());
for b in meta_seg.iter_mut() {
*b ^= XOR_META;
}
// 封面段:PNG 魔数 + 一点数据;cover_len 故意大于 img_len 以覆盖"跳过尾部"
let img: Vec<u8> = [
&[0x89u8, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A][..],
&[7u8; 40],
]
.concat();
let cover_padding = [0u8; 9];
let cover_frame_len = (img.len() + cover_padding.len()) as u32;
let mut container = Vec::new();
container.extend_from_slice(MAGIC);
container.extend_from_slice(&[0x02, 0x00]); // 固定 2B
container.extend_from_slice(&(key_seg.len() as u32).to_le_bytes());
container.extend_from_slice(&key_seg);
container.extend_from_slice(&(meta_seg.len() as u32).to_le_bytes());
container.extend_from_slice(&meta_seg);
container.extend_from_slice(&[0xAA, 0xBB, 0xCC, 0xDD, 0x01]); // CRC32 + 图片版本
container.extend_from_slice(&cover_frame_len.to_le_bytes());
container.extend_from_slice(&(img.len() as u32).to_le_bytes());
container.extend_from_slice(&img);
container.extend_from_slice(&cover_padding);
container.extend_from_slice(&cipher_audio);
let src = dir.join("测试 曲目.ncm");
std::fs::write(&src, &container).unwrap();
assert!(sniff(&src), "合法容器的 sniff 应为 true");
let mut reserved = std::collections::HashSet::new();
let mut ticks = 0usize;
let res = decrypt_file(&src, &out, "网易云", &mut reserved, |_, _| ticks += 1)
.expect("解密应成功");
assert_eq!(res.format, "flac");
assert_eq!(res.audio_bytes, plain.len() as u64);
assert!(ticks >= 2, "进度回调应至少触发两次(跨块),实得 {ticks}");
// 用长度 + 位置比较,避免 assert_eq! 在失败时倾倒几十万字节
let got = std::fs::read(&res.output).unwrap();
assert_eq!(got.len(), plain.len(), "音频长度不一致");
let first_diff = got.iter().zip(plain.iter()).position(|(a, b)| a != b);
assert!(
got == plain,
"音频明文不一致:第一个不同处在第 {:?} 字节",
first_diff
);
// 元数据不再单独暴露,而是拼进 note——所以直接验 note 里带上了它
assert!(res.note.contains("合成曲"), "note 应含曲名:{}", res.note);
assert!(res.note.contains("测试歌手"), "note 应含歌手:{}", res.note);
assert!(res.note.contains("合成专辑"), "note 应含专辑:{}", res.note);
// 位率 320000 → 320 kbps
assert!(res.note.contains("320 kbps"), "note 应含位率:{}", res.note);
let cover = res.cover.expect("应提取出封面");
let cover_bytes = std::fs::read(&cover).unwrap();
assert_eq!(cover_bytes.len(), img.len(), "封面长度不一致");
assert!(cover_bytes == img, "封面字节不一致");
assert_eq!(cover.extension().unwrap(), "png");
// 中文文件名 + 中文输出路径:产物名应保留原名
assert_eq!(
res.output.file_name().unwrap().to_string_lossy(),
"测试 曲目.flac"
);
// 再解一次:同名必须让位而不是覆盖
let res2 =
decrypt_file(&src, &out, "网易云", &mut reserved, |_, _| {}).expect("二次解密应成功");
assert_eq!(
res2.output.file_name().unwrap().to_string_lossy(),
"测试 曲目_1.flac"
);
let _ = std::fs::remove_dir_all(&dir);
}
}
+113
View File
@@ -0,0 +1,113 @@
//! **开发探针**:不落盘地跑完「musicex 尾部 → 凭据 → 在线取密钥 → 解密」并回传结果。
//!
//! 存在的唯一理由:musicex 这条路径的**真实响应字段**只能靠真机样本验证,
//! 而跑起整个 Tauri 应用再手点一遍成本太高、也没法在命令行里复现。
//! 它不参与产品逻辑——调度层走的是 [`super::qq_online::decrypt_musicex`]。
//!
//! 2026-09-27 用它跑通了首个真机样本(197MB `.mflac`,192kHz/24bit):
//! ekey 704 字符 → 派生 512 字节密钥 → RC4 变体解密 → `fLaC` 头。
//! **这条验证顺带推翻了一个错误假设**:该样本的密文头是 `51 74 03 75`,
//! 并非文档里提到的 `#!Qk`,所以密文头不能当守卫(见 `qq_online` 的注释)。
//!
//! 用法见 `src-tauri/examples/decrypt_musicex_probe.rs`:
//! ```text
//! cargo run --example decrypt_musicex_probe -- "C:\path\to\sample.mflac" [输出目录]
//! ```
use std::io::Read;
use std::path::Path;
use super::common::DecryptError;
use super::qmc;
use super::qq_credentials;
use super::qq_ekey::{self, EvkeyRequest};
use super::qq_footer::{self, MusiCexTail};
/// 探针结果(都是"结论性"字段,便于一眼判断链路是否通了)
pub struct ProbeOutcome {
pub ekey_len: usize,
pub key_len: usize,
pub raw_key_bytes: Vec<u8>,
/// 密文头部 4 字节(应是 `#!Qk`,即 QMC2 魔术)
pub cipher_magic: Vec<u8>,
/// 解密后头部 16 字节(FLAC 应为 `fLaC`)
pub plain_magic: Vec<u8>,
pub decrypted_bytes: usize,
pub guessed_format: String,
pub expiration_secs: i64,
}
/// 对给定样本跑完整链路(**读内存、发网络请求、解密,但不写任何文件**)
pub fn probe_musicex(input: &Path) -> Result<ProbeOutcome, DecryptError> {
let total = std::fs::metadata(input).map(|m| m.len()).unwrap_or(0);
if total < qq_footer::MUSICEX_FOOTER_LEN as u64 {
return Err(DecryptError::Broken("文件太小,不可能是 musicex".into()));
}
// 1) 尾部
let tail: MusiCexTail = read_tail(input)?;
let audio_len = tail.audio_len(total);
// 2) 凭据
let creds = qq_credentials::read_credentials();
let (Some(uin), Some(authst)) = (creds.uin.as_deref(), creds.authst.as_deref()) else {
return Err(DecryptError::KeyRequired(format!(
"凭据不可用:{}",
creds.status_text()
)));
};
// 3) 取 ekey(真实网络请求)
let req = EvkeyRequest::from_tail(&tail, uin, authst)?;
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(25))
.build()
.map_err(|e| DecryptError::KeyRequired(format!("构建 HTTP 客户端失败:{e}")))?;
let (ekey, expiration_secs) =
tauri::async_runtime::block_on(qq_ekey::fetch_ekey(&client, &req))?;
// 4) ekey → 原始密钥
let raw = qmc::parse_ekey(&ekey)?;
// 5) 解密音频段(探针只验证单文件,全量读入内存即可)
let mut audio = read_audio(input, audio_len)?;
let cipher_magic = audio[..4.min(audio.len())].to_vec();
qmc::decrypt_with_raw_key(&raw, &mut audio);
let plain_magic = audio[..16.min(audio.len())].to_vec();
let guessed_format = super::common::detect_format_opt(&audio)
.unwrap_or("unknown")
.to_string();
Ok(ProbeOutcome {
ekey_len: ekey.len(),
key_len: raw.len(),
raw_key_bytes: raw,
cipher_magic,
plain_magic,
decrypted_bytes: audio.len(),
guessed_format,
expiration_secs,
})
}
/// 读文件末尾的 musicex 尾部
fn read_tail(input: &Path) -> Result<MusiCexTail, DecryptError> {
use std::io::{Seek, SeekFrom};
let mut f = std::fs::File::open(input)?;
let size = f.metadata()?.len();
let take = (qq_footer::MUSICEX_FOOTER_LEN as u64).min(size) as usize;
f.seek(SeekFrom::End(-(take as i64)))?;
let mut buf = vec![0u8; take];
f.read_exact(&mut buf)?;
qq_footer::parse_musicex_tail(&buf)
.ok_or_else(|| DecryptError::Broken("musicex 尾部解析失败".into()))
}
/// 只读音频段
fn read_audio(input: &Path, audio_len: u64) -> Result<Vec<u8>, DecryptError> {
let mut f = std::fs::File::open(input)?;
let mut buf = vec![0u8; audio_len as usize];
f.read_exact(&mut buf)?;
Ok(buf)
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,285 @@
//! QQ音乐本机凭据读取(`uin` + `authst`)。
//!
//! ## 为什么要读进程内存
//!
//! Windows 版 QQ 音乐**没有持久化 `authst`**:`uin` 能从
//! `%APPDATA%\Tencent\QQMusic\QQMusicServiceConfig.ini` 明文读到,但 `authst`
//! 只作为 JSON 字符串存在于运行中的 `QQMusic.exe` 内存里(有效期约 22.3 小时)。
//! 所以「在线取 ekey」的前置条件是:**QQ 音乐正在运行且已登录**。
//!
//! 这里只做**只读**内存访问(`OpenProcess` + `VirtualQueryEx` + `ReadProcessMemory`),
//! 不注入、不改写任何东西——这是它与 Frida 兜底方案的本质区别,
//! 也是它通常不会被安全软件拦截的原因。
//!
//! ## 结构
//!
//! - [`parse_ini_uin`]:纯函数,可跨平台单测;
//! - [`find_authst`]:纯函数,在给定字节里找 `"authst":"<token>"`,可单测;
//! - [`read_credentials`]:平台相关的胶水(Windows 实现 / 其他平台的空实现)。
/// 从 QQ 音乐的 INI 文本里取 `[Account] Uin`。
///
/// 该文件很小(实测 27 字节)且是**纯文本**,格式固定:
///
/// ```ini
/// [Account]
/// Uin=1154027699
/// ```
///
/// 解析上刻意宽松:允许前导空白、大小写不敏感、允许 `Uin` 出现在任意段里
/// (不同版本段名可能变),但**只认第一处**出现的非空 Uin。
pub fn parse_ini_uin(text: &str) -> Option<String> {
for line in text.lines() {
let line = line.trim();
if line.is_empty() || line.starts_with(';') || line.starts_with('#') {
continue;
}
let Some((key, value)) = line.split_once('=') else {
continue;
};
if !key.trim().eq_ignore_ascii_case("uin") {
continue;
}
let v = value.trim().trim_matches('"');
// 必须是纯数字(QQ 号),排除 `Uin=` 之类的空值或占位
if !v.is_empty() && v.bytes().all(|b| b.is_ascii_digit()) {
return Some(v.to_string());
}
}
None
}
/// `authst` 在内存里的 JSON 形态:`"authst":"<base64url-ish>"`。
const AUTHST_KEY: &[u8] = b"\"authst\":\"";
/// 在一段内存字节里查找 `authst` 的值(从 0 开始)。
///
/// 生产路径用 [`find_authst_from`](分块扫描需要偏移),这个薄封装给测试用。
#[cfg_attr(not(test), allow(dead_code))]
pub fn find_authst(haystack: &[u8]) -> Option<String> {
find_authst_from(haystack, 0)
}
/// 从 `start` 起查找(供分块扫描时避免重复命中同一处)
pub fn find_authst_from(haystack: &[u8], start: usize) -> Option<String> {
let mut pos = start;
while pos + AUTHST_KEY.len() <= haystack.len() {
let Some(rel) = find_subslice(&haystack[pos..], AUTHST_KEY) else {
return None;
};
let val_start = pos + rel + AUTHST_KEY.len();
// token 到下一个双引号结束
let Some(end_rel) = haystack[val_start..].iter().position(|&b| b == b'"') else {
return None;
};
let token = &haystack[val_start..val_start + end_rel];
if is_plausible_token(token) {
return Some(String::from_utf8_lossy(token).to_string());
}
// 命中但是假阳性:从下一个字节继续找
pos = val_start;
}
None
}
fn find_subslice(haystack: &[u8], needle: &[u8]) -> Option<usize> {
if needle.is_empty() || haystack.len() < needle.len() {
return None;
}
haystack.windows(needle.len()).position(|w| w == needle)
}
fn is_plausible_token(token: &[u8]) -> bool {
token.len() >= 16
&& token.iter().all(|&b| {
b.is_ascii_alphanumeric()
|| b == b'-'
|| b == b'_'
|| b == b'='
|| b == b'+'
|| b == b'/'
})
}
/// 凭据读取结果
#[derive(Debug, Clone, Default)]
pub struct QqCredentials {
/// QQ 号(来自 INI)
pub uin: Option<String>,
/// 运行期认证令牌(来自进程内存)
pub authst: Option<String>,
}
impl QqCredentials {
/// 是否可用于调用 `GetEVkey`
pub fn usable(&self) -> bool {
self.uin.is_some() && self.authst.is_some()
}
/// 给 UI 的简短状态(三态,供状态卡渲染)
pub fn status_text(&self) -> &'static str {
match (self.uin.is_some(), self.authst.is_some()) {
(true, true) => "已就绪",
(true, false) => "QQ 音乐未运行或未登录",
(false, _) => "未找到本机 QQ 音乐账号",
}
}
}
/// `QQMusic.exe` 的进程名(枚举时用大小写不敏感的子串匹配)
pub const QQ_PROCESS_HINT: &str = "qqmusic";
/// QQ 音乐配置 INI 的路径(Windows)
#[cfg(windows)]
pub fn config_ini_path() -> Option<std::path::PathBuf> {
let appdata = std::env::var_os("APPDATA")?;
Some(
std::path::PathBuf::from(appdata)
.join("Tencent")
.join("QQMusic")
.join("QQMusicServiceConfig.ini"),
)
}
#[cfg(not(windows))]
pub fn config_ini_path() -> Option<std::path::PathBuf> {
None
}
/// 读凭据:`uin` 从 INI,`authst` 扫进程内存。
///
/// 任何一步失败都只是 `None`(并记日志),不返回错误——调用方据
/// [`QqCredentials::usable`] 决定是走在线取 ekey 还是给出引导。
pub fn read_credentials() -> QqCredentials {
let uin = config_ini_path()
.and_then(|p| std::fs::read_to_string(&p).ok())
.and_then(|t| parse_ini_uin(&t))
.or_else(|| {
// 兜底:文件读不到时,从进程内存里找 "uin":"..." 形态
scan_authst_in_process().1
});
let (authst, uin_from_mem) = match uin {
// 有 uin 时只需要 authst
Some(_) => (scan_authst_in_process().0, None),
// 没 uin 时一次扫描同时拿两者
None => {
let (a, u) = scan_authst_in_process();
(a, u)
}
};
QqCredentials {
uin: uin.or(uin_from_mem),
authst,
}
}
#[cfg(windows)]
fn scan_authst_in_process() -> (Option<String>, Option<String>) {
match crate::music::decrypt::qq_memscan::scan_qq_process() {
Ok(found) => (found.authst, found.uin),
Err(e) => {
crate::logger::log_warn("music-decrypt", &format!("扫描 QQ 音乐进程内存失败:{e}"));
(None, None)
}
}
}
#[cfg(not(windows))]
fn scan_authst_in_process() -> (Option<String>, Option<String>) {
(None, None)
}
#[cfg(test)]
mod tests {
use super::*;
// ============ INI 解析 ============
#[test]
fn parses_real_ini_shape() {
// 本机实测就是这个形状(27 字节)
let text = "[Account]\r\nUin=1154027699\r\n";
assert_eq!(parse_ini_uin(text).as_deref(), Some("1154027699"));
}
#[test]
fn parses_ini_leniently() {
// 大小写、空白、引号、注释、其他段
let text = "\u{feff}; comment\r\n[Other]\r\nx=1\r\n\r\n uin = \"123456\" \r\n";
assert_eq!(parse_ini_uin(text).as_deref(), Some("123456"));
}
#[test]
fn ignores_non_numeric_or_empty_uin() {
assert!(parse_ini_uin("Uin=\r\n").is_none());
assert!(parse_ini_uin("Uin=abc\r\n").is_none());
assert!(parse_ini_uin("Uin=12a45\r\n").is_none());
assert!(parse_ini_uin("").is_none());
assert!(parse_ini_uin("[Account]\nFoo=1\n").is_none());
}
// ============ authst 提取 ============
#[test]
fn finds_authst_in_memory_blob() {
let token = "AbCd_-1234567890AbCd_-1234567890";
let blob = format!("junk{{\"uin\":\"1154027699\",\"authst\":\"{token}\",\"other\":1}}tail");
assert_eq!(find_authst(blob.as_bytes()).as_deref(), Some(token));
}
#[test]
fn rejects_implausible_authst() {
// 太短
assert!(find_authst(b"\"authst\":\"short\"").is_none());
// 含非法字符(像模板/日志)
assert!(find_authst(b"\"authst\":\"this is not a token at all\"").is_none());
// 没有值
assert!(find_authst(b"\"authst\":\"\"").is_none());
// 完全没有
assert!(find_authst(b"nothing here").is_none());
}
/// 第一处是假阳性时,应继续往后找真 token
#[test]
fn skips_false_positive_and_keeps_searching() {
let token = "RealToken_1234567890abcdef";
let blob = format!("\"authst\":\"x\"...\"authst\":\"{token}\"");
assert_eq!(find_authst(blob.as_bytes()).as_deref(), Some(token));
}
/// 跨缓冲区边界不会误判(分块扫描用 find_authst_from)
#[test]
fn find_from_offset_advances() {
let blob = b"aaaa\"authst\":\"AAAAAAAAAAAAAAAA\"";
let first = find_authst_from(blob, 0).unwrap();
assert_eq!(first, "AAAAAAAAAAAAAAAA");
// 从命中处之后继续找应该没有第二个
let key_at = 4 + AUTHST_KEY.len();
assert!(find_authst_from(blob, key_at).is_none());
}
// ============ 状态文案 ============
#[test]
fn credentials_status_text_covers_three_states() {
let none = QqCredentials::default();
assert!(!none.usable());
assert!(none.status_text().contains("未找到"));
let uin_only = QqCredentials {
uin: Some("1".into()),
authst: None,
};
assert!(!uin_only.usable());
assert!(uin_only.status_text().contains("未运行"));
let full = QqCredentials {
uin: Some("1".into()),
authst: Some("t".into()),
};
assert!(full.usable());
assert_eq!(full.status_text(), "已就绪");
}
}
+342
View File
@@ -0,0 +1,342 @@
//! 通过 QQ 音乐官方接口取 ekey(`music.vkey.GetEVkey`)。
//!
//! ## 前置条件(必须让用户知道)
//!
//! 新版 musicex 文件**不包含 ekey**,只能拿本机已登录的凭据向 QQ 音乐服务器换取:
//!
//! 1. 本机装有 QQ 音乐客户端;
//! 2. **QQ 音乐正在运行且已登录**(`authst` 只存在于运行期内存,见
//! [`super::qq_credentials`]);
//! 3. 文件本身的尾部要有 `media_mid` 与 `filename`(musicex 尾部提供)。
//!
//! ## 接口契约里三个"必须"
//!
//! 对照 `MUSIC_DECRYPT_PLAN.md` §3.2 与 qmc-decoder 的协议文档:
//!
//! - `param.filename` **必须带扩展名**(`.mgg` / `.mflac`),否则返回 `104005`;
//! - `param.songtype` **必须为 `1`**(表示请求加密资源的 ekey;为 0 只回 vkey);
//! - `module` 必须是 **`music.vkey.GetEVkey`**(不是 `GetVkey`,后者不返回 ekey)。
//!
//! 另外 `authst` 约 **22.3 小时**过期,失败文案要给出"重新登录 QQ 音乐"的出口。
use serde::{Deserialize, Serialize};
use super::common::DecryptError;
use super::qq_footer::MusiCexTail;
/// 取 ekey 的接口地址
pub const EVKEY_ENDPOINT: &str = "https://u.y.qq.com/cgi-bin/musicu.fcg";
/// PC 端的 platform 标识(Windows)
pub const PLATFORM_WINDOWS: &str = "27";
/// 组装 `GetEVkey` 请求体。
///
/// 抽成纯函数是为了能单测那三个"必须"——它们是这个接口最容易踩的坑。
pub fn build_evkey_request(
uin: &str,
authst: &str,
media_mid: &str,
filename: &str,
login_type: u32,
) -> serde_json::Value {
serde_json::json!({
"comm": {
"authst": authst,
"ct": "19",
"cv": "1859",
"uin": uin,
"tmeLoginType": login_type.to_string(),
},
"req_1": {
"module": "music.vkey.GetEVkey",
"method": "CgiGetEVkey",
"param": {
"filename": [filename],
"guid": "10000",
"songmid": [media_mid],
"songtype": [1],
"uin": uin,
"loginflag": 1,
"platform": PLATFORM_WINDOWS,
"ctx": 1,
}
}
})
}
/// `GetEVkey` 的响应(只声明用得到的字段)
#[derive(Debug, Clone, Deserialize)]
pub struct EvkeyResponse {
#[serde(default)]
pub code: i64,
#[serde(default)]
pub req_1: Option<EvkeyReq1>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct EvkeyReq1 {
#[serde(default)]
pub code: i64,
#[serde(default)]
pub data: Option<EvkeyData>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct EvkeyData {
#[serde(default)]
pub midurlinfo: Vec<EvkeyItem>,
/// ekey 有效期(秒),实测约 80400
#[serde(default)]
pub expiration: i64,
}
#[derive(Debug, Clone, Deserialize)]
pub struct EvkeyItem {
#[serde(default)]
pub ekey: String,
#[serde(default)]
pub result: i64,
#[serde(default)]
pub subcode: i64,
}
/// 把响应解读为 `(ekey, 有效期秒数)` 或一个**可读的**失败原因。
///
/// 这里集中处理错误码,是为了让 UI 能给出下一步动作,而不是丢一个数字出去。
/// 有效期一并返回:`authst` 过期是这条链路最常见的失败原因,把"还能用多久"
/// 讲清楚比让用户猜要好。
pub fn parse_evkey_response(resp: &EvkeyResponse) -> Result<(String, i64), DecryptError> {
let req = resp
.req_1
.as_ref()
.ok_or_else(|| DecryptError::KeyRequired("服务器响应缺少 req_1".into()))?;
let data = req
.data
.as_ref()
.ok_or_else(|| DecryptError::KeyRequired("服务器响应缺少 data".into()))?;
let item = data
.midurlinfo
.first()
.ok_or_else(|| DecryptError::KeyRequired("服务器未返回任何资源信息".into()))?;
if item.ekey.is_empty() {
let hint = match item.result {
104005 => {
"该资源的密钥需要 VIP 或当前账号无权访问(错误码 104005);也可能文件名缺少扩展名"
}
0 => "服务器返回了空 ekey,通常是登录态已过期——请在 QQ 音乐里重新登录后重试",
_ => "服务器未返回 ekey",
};
return Err(DecryptError::KeyRequired(format!(
"{hint}(result={}, subcode={}, code={}/{}/{})",
item.result, item.subcode, resp.code, req.code, item.result
)));
}
Ok((item.ekey.clone(), data.expiration))
}
/// 从响应 JSON 文本解析出 ekey。
///
/// 生产路径走 [`fetch_ekey`](它需要有效期),这个薄封装主要给测试用,
/// 也作为该接口对外的最小 API。
#[cfg_attr(not(test), allow(dead_code))]
pub fn extract_ekey(body: &str) -> Result<String, DecryptError> {
let resp: EvkeyResponse = serde_json::from_str(body)
.map_err(|e| DecryptError::KeyRequired(format!("解析服务器响应失败:{e}")))?;
parse_evkey_response(&resp).map(|(ekey, _)| ekey)
}
/// 在线取 ekey 的入参(把"要什么"与"怎么取"分开,便于测试与日志)
#[derive(Debug, Clone, Serialize)]
pub struct EvkeyRequest {
pub uin: String,
pub authst: String,
pub media_mid: String,
pub filename: String,
pub login_type: u32,
}
impl EvkeyRequest {
/// 从 musicex 尾部 + 凭据构造
pub fn from_tail(tail: &MusiCexTail, uin: &str, authst: &str) -> Result<Self, DecryptError> {
if tail.media_mid.is_empty() {
return Err(DecryptError::Broken(
"musicex 尾部缺少 media_mid,无法向服务器索取密钥".into(),
));
}
if tail.filename.is_empty() {
return Err(DecryptError::Broken(
"musicex 尾部缺少文件名,无法向服务器索取密钥".into(),
));
}
// 接口要求 filename 必须带扩展名
if !tail.filename.contains('.') {
return Err(DecryptError::Broken(
"musicex 尾部文件名没有扩展名,服务器会拒绝(104005)".into(),
));
}
Ok(Self {
uin: uin.to_string(),
authst: authst.to_string(),
media_mid: tail.media_mid.clone(),
filename: tail.filename.clone(),
// 默认按 QQ 登录;微信登录是 3,两者都能用 authst,不影响取 ekey
login_type: 1,
})
}
pub fn body(&self) -> serde_json::Value {
build_evkey_request(
&self.uin,
&self.authst,
&self.media_mid,
&self.filename,
self.login_type,
)
}
}
/// 实际发请求(异步),返回 `(ekey, 有效期秒数)`。
pub async fn fetch_ekey(
client: &reqwest::Client,
req: &EvkeyRequest,
) -> Result<(String, i64), DecryptError> {
let body = req.body();
let resp = tokio::time::timeout(
std::time::Duration::from_secs(20),
client.post(EVKEY_ENDPOINT).json(&body).send(),
)
.await
.map_err(|_| DecryptError::KeyRequired("请求 QQ 音乐服务器超时".into()))?
.map_err(|e| DecryptError::KeyRequired(format!("请求 QQ 音乐服务器失败:{e}")))?;
let status = resp.status();
let text = resp
.text()
.await
.map_err(|e| DecryptError::KeyRequired(format!("读取服务器响应失败:{e}")))?;
if !status.is_success() {
return Err(DecryptError::KeyRequired(format!(
"QQ 音乐服务器返回 HTTP {status}:{}",
text.chars().take(200).collect::<String>()
)));
}
parse_evkey_response(
&serde_json::from_str(&text)
.map_err(|e| DecryptError::KeyRequired(format!("解析服务器响应失败:{e}")))?,
)
}
#[cfg(test)]
mod tests {
use super::*;
fn tail() -> MusiCexTail {
MusiCexTail {
song_id: 1,
media_mid: "0012ABCDEF".into(),
filename: "O4M00012ABCDEF.mgg".into(),
footer_size: 192,
version: 1,
..Default::default()
}
}
/// 接口契约的三个"必须"——写错了不会报错,只会静默拿不到 ekey
#[test]
fn request_body_satisfies_api_contract() {
let req = EvkeyRequest::from_tail(&tail(), "1154027699", "TOKEN").unwrap();
let body = req.body();
assert_eq!(body["req_1"]["module"], "music.vkey.GetEVkey");
assert_eq!(body["req_1"]["method"], "CgiGetEVkey");
let param = &body["req_1"]["param"];
// songtype 必须为 1(加密资源)
assert_eq!(param["songtype"][0], 1);
// filename 必须带扩展名
assert_eq!(param["filename"][0], "O4M00012ABCDEF.mgg");
assert!(param["filename"][0].as_str().unwrap().contains('.'));
// songmid 来自 media_mid
assert_eq!(param["songmid"][0], "0012ABCDEF");
// platform = 27(Windows)
assert_eq!(param["platform"], "27");
// comm 里要带 authst / uin
assert_eq!(body["comm"]["authst"], "TOKEN");
assert_eq!(body["comm"]["uin"], "1154027699");
}
#[test]
fn from_tail_rejects_incomplete_tail() {
let mut t = tail();
t.media_mid.clear();
assert!(EvkeyRequest::from_tail(&t, "1", "T").is_err());
let mut t = tail();
t.filename.clear();
assert!(EvkeyRequest::from_tail(&t, "1", "T").is_err());
// 没有扩展名的文件名会被服务器拒绝,提前拦下
let mut t = tail();
t.filename = "O4M00012ABCDEF".into();
let err = EvkeyRequest::from_tail(&t, "1", "T").unwrap_err();
assert!(err.to_string().contains("扩展名"));
}
#[test]
fn parses_successful_response() {
let body = r#"{
"code": 0,
"req_1": { "code": 0, "data": {
"midurlinfo": [{ "ekey": "REAL_EKEY", "result": 0, "subcode": 0 }],
"expiration": 80400
}}
}"#;
assert_eq!(extract_ekey(body).unwrap(), "REAL_EKEY");
}
/// 104005:要么需要 VIP,要么 filename 没带扩展名——文案必须点出这两条
#[test]
fn error_104005_is_actionable() {
let body = r#"{
"code": 0,
"req_1": { "code": 0, "data": {
"midurlinfo": [{ "ekey": "", "result": 104005, "subcode": 0 }]
}}
}"#;
let err = extract_ekey(body).unwrap_err();
let msg = err.to_string();
assert!(msg.contains("104005"), "应带错误码:{msg}");
assert!(msg.contains("VIP"), "应提示 VIP:{msg}");
assert!(msg.contains("扩展名"), "应提示文件名要求:{msg}");
}
/// result=0 但 ekey 为空 → 登录态过期
#[test]
fn empty_ekey_with_result_zero_suggests_relogin() {
let body = r#"{
"code": 0,
"req_1": { "code": 0, "data": {
"midurlinfo": [{ "ekey": "", "result": 0, "subcode": 0 }]
}}
}"#;
let msg = extract_ekey(body).unwrap_err().to_string();
assert!(msg.contains("重新登录"), "应提示重新登录:{msg}");
}
#[test]
fn missing_sections_are_reported() {
assert!(extract_ekey(r#"{"code":0}"#).is_err());
assert!(extract_ekey(r#"{"code":0,"req_1":{"code":0}}"#).is_err());
assert!(extract_ekey(r#"{"code":0,"req_1":{"code":0,"data":{"midurlinfo":[]}}}"#).is_err());
}
#[test]
fn malformed_json_is_reported() {
let err = extract_ekey("not json").unwrap_err();
assert!(err.to_string().contains("解析"));
}
}
+231
View File
@@ -0,0 +1,231 @@
//! QQ音乐 **musicex** 尾部解析(QQ 客户端 ≥ 19.57 / Windows 22.x)。
//!
//! 新版客户端不再把 ekey 写进文件,只在末尾留 192 字节元数据,ekey 必须联网取。
//! 这个模块只做**纯解析**(无 IO、无网络),因此可以完整单测。
//!
//! ## 尾部布局(对照 `MUSIC_DECRYPT_PLAN.md` §3.2 与 qmc-decoder 的格式文档)
//!
//! ```text
//! +0x00 [4B] song_id uint32 LE
//! +0x04 [4B] quality_type1 uint32 LE
//! +0x08 [4B] quality_type2 uint32 LE
//! +0x0C [60B] media_mid UTF-16LE(可能以 NUL 结尾)
//! +0x48 [68B] filename UTF-16LE(含扩展名,如 O4M0xxxx.mgg)
//! +0x8C [48B] padding
//! +0xC0 [4B] footer_size uint32 LE(= 0xC0 = 192)
//! +0xC4 [4B] version uint32 LE(= 1)
//! +0xC8 [8B] magic "musicex\0"
//! ```
//!
//! 因此**音频段 = 文件大小 − footer_size**,且 footer 一定在文件末尾。
/// musicex 尾部魔术(含结尾 NUL)
pub const MUSICEX_MAGIC: &[u8; 8] = b"musicex\0";
/// 尾部固定长度(也是 footer_size 字段的期望值)
pub const MUSICEX_FOOTER_LEN: usize = 0xC0;
/// 解析出的 musicex 元数据
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct MusiCexTail {
pub song_id: u32,
pub quality_type1: u32,
pub quality_type2: u32,
/// 歌曲 mid(取 ekey 需要)
pub media_mid: String,
/// 资源文件名(**必须含扩展名**,否则 API 返回 104005)
pub filename: String,
/// 尾部声明的长度(正常为 192)
pub footer_size: u32,
pub version: u32,
}
impl MusiCexTail {
/// 音频段长度(文件总大小 − 尾部长度)
pub fn audio_len(&self, file_size: u64) -> u64 {
file_size.saturating_sub(self.footer_size as u64)
}
/// 给 UI 的一行说明
pub fn note(&self) -> String {
if self.filename.is_empty() {
format!("musicex(songId={})", self.song_id)
} else {
format!("musicex · {}", self.filename)
}
}
}
/// 判断一段**文件尾部字节**是否是 musicex 尾部。
pub fn is_musicex_tail(buf: &[u8]) -> bool {
buf.len() >= 8 && &buf[buf.len() - 8..] == MUSICEX_MAGIC
}
/// 从文件末尾字节解析 musicex 尾部。
///
/// `buf` 必须至少包含整个尾部([`MUSICEX_FOOTER_LEN`] 字节),否则返回 `None`。
pub fn parse_musicex_tail(buf: &[u8]) -> Option<MusiCexTail> {
if !is_musicex_tail(buf) {
return None;
}
let n = buf.len();
let footer_size = le_u32(buf, n - 16)?;
let version = le_u32(buf, n - 12)?;
// footer_size 是尾部总长;它必须落在缓冲区里才谈得上解析字段
let footer_size_usize = footer_size as usize;
if footer_size_usize < MUSICEX_FOOTER_LEN || footer_size_usize > n {
return None;
}
let start = n - footer_size_usize;
Some(MusiCexTail {
song_id: le_u32(buf, start)?,
quality_type1: le_u32(buf, start + 4)?,
quality_type2: le_u32(buf, start + 8)?,
media_mid: utf16le_at(buf, start + 0x0C, 60)?,
filename: utf16le_at(buf, start + 0x48, 68)?,
footer_size,
version,
})
}
fn le_u32(b: &[u8], at: usize) -> Option<u32> {
let end = at.checked_add(4)?;
let s = b.get(at..end)?;
Some(u32::from_le_bytes([s[0], s[1], s[2], s[3]]))
}
/// 读取定长 UTF-16LE 字段并去掉结尾的 NUL。
///
/// 字段是定长补齐的,未用部分为 0;也可能不补 NUL 而恰好占满,故两种都要容忍。
fn utf16le_at(buf: &[u8], at: usize, byte_len: usize) -> Option<String> {
let end = at.checked_add(byte_len)?;
let s = buf.get(at..end)?;
let mut units: Vec<u16> = s
.chunks_exact(2)
.map(|c| u16::from_le_bytes([c[0], c[1]]))
.collect();
while units.last() == Some(&0) {
units.pop();
}
Some(String::from_utf16_lossy(&units))
}
#[cfg(test)]
mod tests {
use super::*;
/// 构造一个合法的 musicex 尾部
fn build_tail(song_id: u32, mid: &str, filename: &str) -> Vec<u8> {
let mut tail = vec![0u8; MUSICEX_FOOTER_LEN];
tail[0..4].copy_from_slice(&song_id.to_le_bytes());
tail[4..8].copy_from_slice(&2u32.to_le_bytes());
tail[8..12].copy_from_slice(&2u32.to_le_bytes());
write_utf16(&mut tail[0x0C..0x0C + 60], mid);
write_utf16(&mut tail[0x48..0x48 + 68], filename);
let n = tail.len();
tail[n - 16..n - 12].copy_from_slice(&(MUSICEX_FOOTER_LEN as u32).to_le_bytes());
tail[n - 12..n - 8].copy_from_slice(&1u32.to_le_bytes());
tail[n - 8..].copy_from_slice(MUSICEX_MAGIC);
tail
}
fn write_utf16(dst: &mut [u8], s: &str) {
for (i, unit) in s.encode_utf16().enumerate() {
let at = i * 2;
if at + 2 > dst.len() {
break;
}
dst[at..at + 2].copy_from_slice(&unit.to_le_bytes());
}
}
#[test]
fn parses_valid_footer() {
let tail = build_tail(0x0C27ABCD, "0012ABCDEF", "O4M00012ABCDEF.mgg");
let parsed = parse_musicex_tail(&tail).expect("应解析成功");
assert_eq!(parsed.song_id, 0x0C27ABCD);
assert_eq!(parsed.quality_type1, 2);
assert_eq!(parsed.quality_type2, 2);
assert_eq!(parsed.media_mid, "0012ABCDEF");
assert_eq!(parsed.filename, "O4M00012ABCDEF.mgg");
assert_eq!(parsed.footer_size, 192);
assert_eq!(parsed.version, 1);
}
/// 尾部前面还有音频数据时,解析结果不受影响(按 footer_size 定位)
#[test]
fn parses_footer_with_audio_prefix() {
let tail = build_tail(7, "mid123", "F00000mid123.mflac");
let mut file = vec![0xAAu8; 5000];
file.extend_from_slice(&tail);
let parsed = parse_musicex_tail(&file).expect("应解析成功");
assert_eq!(parsed.filename, "F00000mid123.mflac");
assert_eq!(parsed.audio_len(file.len() as u64), 5000);
}
/// 字段恰好占满、没有 NUL 终止符时也要能读全
#[test]
fn parses_full_width_field_without_nul() {
let name = "A".repeat(34); // 68 字节 = 34 个 UTF-16 单元,正好占满
let tail = build_tail(1, "M", &name);
let parsed = parse_musicex_tail(&tail).expect("应解析成功");
assert_eq!(parsed.filename, name);
}
/// 中文文件名(UTF-16LE)要能正确还原
#[test]
fn parses_cjk_filename() {
let tail = build_tail(1, "mid", "歌曲 名.mgg");
let parsed = parse_musicex_tail(&tail).unwrap();
assert_eq!(parsed.filename, "歌曲 名.mgg");
}
#[test]
fn rejects_non_musicex() {
assert!(!is_musicex_tail(b"not a magic at all"));
assert!(parse_musicex_tail(&[0u8; 192]).is_none());
// 魔术对但长度不合理
let mut bad = vec![0u8; 192];
let n = bad.len();
bad[n - 8..].copy_from_slice(MUSICEX_MAGIC);
bad[n - 16..n - 12].copy_from_slice(&0xFFFFu32.to_le_bytes());
assert!(parse_musicex_tail(&bad).is_none(), "footer_size 越界应拒绝");
}
#[test]
fn rejects_truncated_buffer() {
// 只有 16 字节,放不下 192 字节的尾部结构
let mut short = vec![0u8; 16];
let n = short.len();
short[n - 8..].copy_from_slice(MUSICEX_MAGIC);
short[n - 16..n - 12].copy_from_slice(&192u32.to_le_bytes());
assert!(parse_musicex_tail(&short).is_none());
}
#[test]
fn audio_len_saturates() {
let t = MusiCexTail {
footer_size: 192,
..Default::default()
};
assert_eq!(t.audio_len(1000), 808);
// 文件比尾部还小:不能下溢
assert_eq!(t.audio_len(10), 0);
}
#[test]
fn note_includes_filename_when_present() {
let t = MusiCexTail {
filename: "a.mgg".into(),
song_id: 5,
..Default::default()
};
assert!(t.note().contains("a.mgg"));
let empty = MusiCexTail {
song_id: 9,
..Default::default()
};
assert!(empty.note().contains("9"));
}
}
+216
View File
@@ -0,0 +1,216 @@
//! `QQMusic.exe` 进程内存扫描(**只读**)。
//!
//! Windows 版 QQ 音乐把 `authst` 只放在运行期内存里,因此联网取 ekey 必须先把它捞出来。
//! 这是纯 Win32 胶水层:真正的解析逻辑([`super::qq_credentials::find_authst`] /
//! [`super::qq_credentials::parse_ini_uin`])是跨平台纯函数,已单独单测。
//!
//! ## 实现要点(踩过的坑)
//!
//! 1. **`MEMORY_BASIC_INFORMATION` 的 `PartitionId`**:Windows 10 1803+ 在
//! `AllocationProtect` 与 `RegionSize` 之间插入了 2 字节。结构体里**必须**包含它,
//! 否则 `RegionSize`/`State`/`Protect` 全部从错误偏移读取——症状是
//! `VirtualQueryEx` 返回的 `State` 读成了 `Protect` 的值(如 `PAGE_READWRITE=0x04`
//! 而不是 `MEM_COMMIT=0x1000`),于是**所有内存区域都被跳过**、永远扫不到。
//! `windows-sys` 的定义已经包含该字段,这里直接用官方结构体。
//! 2. **只扫 `MEM_COMMIT` 且可读的区域**,并跳过 `PAGE_GUARD` / `PAGE_NOACCESS`。
//! 3. **分块读取**(1 MB),避免一次 `ReadProcessMemory` 大区域时中途失败整块丢。
//! 4. 跨块保留 `AUTHST_KEY.len() - 1` 字节的重叠,防止 token 恰好横跨块边界。
use std::ffi::c_void;
use windows_sys::Win32::Foundation::{CloseHandle, INVALID_HANDLE_VALUE};
use windows_sys::Win32::System::Diagnostics::Debug::ReadProcessMemory;
use windows_sys::Win32::System::Diagnostics::ToolHelp::{
CreateToolhelp32Snapshot, Process32FirstW, Process32NextW, PROCESSENTRY32W, TH32CS_SNAPPROCESS,
};
use windows_sys::Win32::System::Memory::{
VirtualQueryEx, MEMORY_BASIC_INFORMATION, MEM_COMMIT, PAGE_GUARD, PAGE_NOACCESS,
};
use windows_sys::Win32::System::Threading::{
OpenProcess, PROCESS_QUERY_INFORMATION, PROCESS_VM_READ,
};
use super::qq_credentials::{find_authst_from, QQ_PROCESS_HINT};
/// 单次读取的块大小
const CHUNK: usize = 1024 * 1024;
/// 跨块重叠长度(`"authst":"` 的长度 - 1,防止 token 横跨块边界)
const OVERLAP: usize = 16;
/// 扫描上限:避免异常进程占用过久(每个进程最多读这么多字节)
const MAX_SCAN_BYTES: usize = 512 * 1024 * 1024;
/// 扫描结果
#[derive(Debug, Clone, Default)]
pub struct Found {
pub authst: Option<String>,
pub uin: Option<String>,
}
/// 按进程名(大小写不敏感子串)找 PID
pub fn find_process_pid(hint: &str) -> Option<u32> {
unsafe {
let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if snapshot == INVALID_HANDLE_VALUE {
return None;
}
let mut entry: PROCESSENTRY32W = std::mem::zeroed();
entry.dwSize = std::mem::size_of::<PROCESSENTRY32W>() as u32;
// 提前小写化,避免在进程列表里反复分配(进程数可达数百)
let needle = hint.to_lowercase();
let mut pid: Option<u32> = None;
if Process32FirstW(snapshot, &mut entry) != 0 {
loop {
let name_len = entry
.szExeFile
.iter()
.position(|&c| c == 0)
.unwrap_or(entry.szExeFile.len());
let name = String::from_utf16_lossy(&entry.szExeFile[..name_len]);
if name.to_lowercase().contains(&needle) {
pid = Some(entry.th32ProcessID);
break;
}
if Process32NextW(snapshot, &mut entry) == 0 {
break;
}
}
}
CloseHandle(snapshot);
pid
}
}
/// QQ 音乐是否在运行
pub fn is_qqmusic_running() -> bool {
find_process_pid(QQ_PROCESS_HINT).is_some()
}
/// 扫描 QQ 音乐进程内存,捞出 `authst`(顺带尝试 `"uin":"..."`)。
pub fn scan_qq_process() -> Result<Found, String> {
let pid = find_process_pid(QQ_PROCESS_HINT).ok_or("未找到 QQMusic.exe 进程")?;
// windows-sys 0.52 的 HANDLE 是 isize(0 表示失败)
let handle = unsafe { OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, 0, pid) };
if handle == 0 {
return Err("无法打开 QQMusic.exe(权限不足;请尝试以管理员身份运行本应用)".to_string());
}
let result = unsafe { scan_handle(handle) };
unsafe { CloseHandle(handle) };
result
}
unsafe fn scan_handle(handle: isize) -> Result<Found, String> {
let mut found = Found::default();
let mut address: usize = 0;
let mut buf = vec![0u8; CHUNK];
let mut scanned: usize = 0;
while address < usize::MAX {
let mut mbi: MEMORY_BASIC_INFORMATION = std::mem::zeroed();
let written = VirtualQueryEx(
handle,
address as *const c_void,
&mut mbi,
std::mem::size_of::<MEMORY_BASIC_INFORMATION>(),
);
if written == 0 {
break;
}
let region_size = mbi.RegionSize;
let base = mbi.BaseAddress as usize;
// 只读「已提交、且不是 guard/noaccess」的区域
let readable = mbi.State == MEM_COMMIT
&& (mbi.Protect & PAGE_GUARD) == 0
&& (mbi.Protect & PAGE_NOACCESS) == 0
&& mbi.Protect != 0;
if readable && region_size > 0 {
let mut offset = 0usize;
while offset < region_size && scanned < MAX_SCAN_BYTES {
let want = CHUNK.min(region_size - offset);
// 末尾留出重叠,保证 token 不因分块被截断
let read_len = want.min(buf.len());
let mut got = 0usize;
let ok = ReadProcessMemory(
handle,
(base + offset) as *const c_void,
buf.as_mut_ptr() as *mut c_void,
read_len,
&mut got,
);
if ok != 0 && got > 0 {
scanned += got;
let slice = &buf[..got];
if found.authst.is_none() {
if let Some(t) = find_authst_from(slice, 0) {
found.authst = Some(t);
}
}
if found.uin.is_none() {
found.uin = find_json_string(slice, b"\"uin\":\"");
}
if found.authst.is_some() && found.uin.is_some() {
return Ok(found);
}
}
// 前进:整块减去重叠,避免漏掉跨块的匹配
if want <= OVERLAP {
break;
}
offset += want - OVERLAP;
}
}
// 前进到下一个区域;RegionSize 为 0 时强制前进,防止死循环
let step = if region_size == 0 {
0x1000
} else {
region_size
};
match address.checked_add(step) {
Some(next) if next > address => address = next,
_ => break,
}
}
Ok(found)
}
/// 在字节里找 `"<key>":"<value>"` 形态的字符串值(用于 uin)
unsafe fn find_json_string(haystack: &[u8], key: &[u8]) -> Option<String> {
let mut pos = 0usize;
while pos + key.len() <= haystack.len() {
let rel = haystack[pos..].windows(key.len()).position(|w| w == key)?;
let start = pos + rel + key.len();
let end = haystack[start..].iter().position(|&b| b == b'"')?;
let val = &haystack[start..start + end];
if !val.is_empty() && val.iter().all(|b| b.is_ascii_digit()) {
return Some(String::from_utf8_lossy(val).to_string());
}
pos = start;
}
None
}
#[cfg(test)]
mod tests {
use super::*;
/// 「QQ 在不在运行」必须能在本机跑通且不 panic
/// (本机装了 QQ 音乐,结果可能是 true 或 false,取决于是否启动)
#[test]
fn process_detection_does_not_panic() {
let running = is_qqmusic_running();
// 只要求"不 panic 且能给出结论";不假设本机是否开着 QQ 音乐
eprintln!("QQMusic running = {running}");
}
/// 不存在的进程名必须返回 None,而不是卡住或 panic
#[test]
fn unknown_process_returns_none() {
assert!(find_process_pid("definitely-not-a-real-process-xyzzy").is_none());
}
}
+361
View File
@@ -0,0 +1,361 @@
//! QQ音乐解密的**编排层**:把「尾部形态 → 密钥来源 → 流密码」串起来。
//!
//! 密钥来源按 `MUSIC_DECRYPT_PLAN.md` §3.2 分层:
//!
//! | 尾部 | 密钥来源 | 需要联网 |
//! |---|---|---|
//! | QMC1 | 内置静态表 | 否 |
//! | QTag / V1 | 尾部内嵌 ekey | 否 |
//! | musicex | **本机已登录凭据 → `GetEVkey`** | 是 |
//!
//! 之所以单开一个模块而不是塞进 `qmc.rs`:联网那一路牵涉 HTTP 客户端、
//! 凭据与工作线程里的运行时,与纯算法拆开后 `qmc.rs` 可以保持零 IO 依赖。
use std::path::Path;
use super::common::{self, DecryptError};
use super::qmc;
use super::qq_credentials;
use super::qq_ekey::{self, EvkeyRequest};
use super::qq_footer::{self, MusiCexTail};
/// 在线能力状态(给 UI 状态卡用)
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
#[serde(rename_all = "camelCase")]
pub struct QqOnlineStatus {
/// QQMusic.exe 是否在运行
pub running: bool,
/// 是否取到了 authst(= 已登录且能读到内存)
pub logged_in: bool,
/// 本机读到的 QQ 号(仅用于展示;没有则为 None)
pub uin: Option<String>,
/// 是否具备在线取 ekey 的能力
pub ready: bool,
/// 给用户的一句话状态
pub message: String,
/// 需要用户照做的步骤(ready 时为一条"无需额外设置")
pub steps: Vec<String>,
}
/// 探测在线能力(**只读**:读 INI + 扫进程内存,不发网络请求)
pub fn probe_status() -> QqOnlineStatus {
let running = qq_memscan_running();
let creds = qq_credentials::read_credentials();
let ready = creds.usable();
let message = if ready {
"已就绪:可直接解密 QQ 音乐新版 musicex 文件".to_string()
} else if !running {
"QQ 音乐未运行——新版 musicex 文件的密钥只在登录后存在于内存中".to_string()
} else if creds.uin.is_none() {
"QQ 音乐在运行,但没读到本机账号(可能尚未登录)".to_string()
} else {
"QQ 音乐在运行,但未取到登录令牌(authst),请确认已登录".to_string()
};
let steps = if ready {
vec!["无需额外设置;QMC1 与尾部内嵌 ekey 的文件本来就不需要登录。".to_string()]
} else {
vec![
"1. 在电脑上启动 QQ 音乐客户端(Windows 版)。".to_string(),
"2. 用它登录你的账号(扫码或账号密码均可),并保持客户端开着。".to_string(),
"3. 回到本页点「重新检测」;状态变为「已就绪」后即可解密 musicex 文件。".to_string(),
"4. 若显示未取到登录令牌:先播放任意一首歌触发一次网络请求,再重新检测。".to_string(),
"5. 若仍失败,试过以管理员身份运行本应用(读取进程内存可能受权限限制)。".to_string(),
"6. 登录令牌约 22.3 小时过期;过期后重新检测即可。".to_string(),
]
};
QqOnlineStatus {
running,
logged_in: creds.authst.is_some(),
uin: creds.uin.clone(),
ready,
message,
steps,
}
}
fn qq_memscan_running() -> bool {
#[cfg(windows)]
{
super::qq_memscan::is_qqmusic_running()
}
#[cfg(not(windows))]
{
false
}
}
/// musicex 的联网取密钥 + 解密。
///
/// `client` 用于发请求;调用方负责给它一个带超时的实例。整个流程会在
/// 当前线程上建一个最小 tokio 运行时来 `block_on`——调度层本来就是
/// 独立工作线程,不占 tokio 的工作线程。
pub fn decrypt_musicex<F>(
input: &Path,
out_dir: &Path,
platform_label: &str,
mut progress: F,
) -> Result<common::Outcome, DecryptError>
where
F: FnMut(u64, u64),
{
let total = std::fs::metadata(input).map(|m| m.len()).unwrap_or(0);
if total < qq_footer::MUSICEX_FOOTER_LEN as u64 {
return Err(DecryptError::Broken("文件太小,不可能是 musicex".into()));
}
// 1) 解析尾部
let tail = read_musicex_tail(input)?;
let audio_len = tail.audio_len(total);
// 2) 取凭据
let creds = qq_credentials::read_credentials();
let (uin, authst) = match (creds.uin.as_deref(), creds.authst.as_deref()) {
(Some(u), Some(a)) => (u, a),
_ => {
return Err(DecryptError::KeyRequired(format!(
"{}。请在电脑上启动并登录 QQ 音乐客户端后重试,或在「解密」页点「重新检测」查看当前状态。",
creds.status_text()
)))
}
};
// 3) 请求 ekey
let req = EvkeyRequest::from_tail(&tail, uin, authst)?;
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(25))
.build()
.map_err(|e| DecryptError::KeyRequired(format!("构建 HTTP 客户端失败:{e}")))?;
let (ekey, expiration) = block_on(fetch_ekey_async(&client, &req))?;
// 4) ekey → 原始密钥
let raw = qmc::parse_ekey(&ekey)?;
if raw.len() < 16 || raw.len() > 4096 {
return Err(DecryptError::KeyRequired(format!(
"服务器返回的密钥长度异常({} 字节),已放弃以免解出噪声",
raw.len()
)));
}
// 5) 解密音频段
let audio = read_audio_segment(input, audio_len)?;
// 用**解密结果**判定密钥是否正确,而不是猜密文头。
//
// 曾经的写法是"密文必须以 `#!Qk` 开头,否则拒绝"——**这个假设是错的**:
// 真机样本(Avicii - Heaven,musicex)的密文头是 `51 74 03 75`,
// 按那条守卫会把完全合法的文件误拒。QMC2 密文头没有稳定魔术,
// 而"用取到的密钥解出的前 16 字节是不是已知音频魔术"才可靠:
// 密钥错时它是随机噪声,几乎不可能凑成 `fLaC` / `OggS` / `ID3` / `ftyp`。
let mut plaintext = audio;
qmc::decrypt_with_raw_key(&raw, &mut plaintext);
let Some(format) = super::common::detect_format_opt(&plaintext) else {
return Err(DecryptError::KeyRequired(format!(
"取到的密钥没能解出可识别的音频头(前 16 字节 {:02x?})——可能是该资源的 ekey \
与文件不匹配,或登录态已过期;请重新检测后重试",
&plaintext[..16.min(plaintext.len())]
)));
};
let decrypted = plaintext;
let stem = input
.file_stem()
.map(|s| s.to_string_lossy().to_string())
.unwrap_or_else(|| "output".to_string());
std::fs::create_dir_all(out_dir)?;
let mut reserved = std::collections::HashSet::new();
let target = super::common::unique_output(out_dir, &stem, format, &mut reserved)?;
std::fs::write(&target, &decrypted)?;
progress(decrypted.len() as u64, decrypted.len() as u64);
Ok(common::Outcome {
output: target,
format: format.to_string(),
cover: None,
audio_bytes: decrypted.len() as u64,
note: format!(
"{platform_label} · {} · 在线取密钥解密(密钥有效期约 {} 小时)",
tail.note(),
// expiration 单位为秒(实测约 80400 ≈ 22.3 小时)
if expiration > 0 {
format!("{:.1}", expiration as f64 / 3600.0)
} else {
"未知".to_string()
}
),
})
}
/// 读文件末尾的 musicex 尾部
fn read_musicex_tail(input: &Path) -> Result<MusiCexTail, DecryptError> {
use std::io::{Read, Seek, SeekFrom};
let mut f = std::fs::File::open(input)?;
let size = f.metadata()?.len();
let take = (qq_footer::MUSICEX_FOOTER_LEN as u64).min(size) as usize;
f.seek(SeekFrom::End(-(take as i64)))?;
let mut buf = vec![0u8; take];
f.read_exact(&mut buf)?;
// 注意:这里只读了尾部 192 字节,而 footer_size 可能 > 192(版本变化)——
// 那就退化成"按已知长度解析",字段偏移仍以文件末尾为基准。
qq_footer::parse_musicex_tail(&buf)
.ok_or_else(|| DecryptError::Broken("musicex 尾部解析失败(魔术或长度字段异常)".into()))
}
/// 只读音频段(musicex 场景下文件不大,但依然按大小一次读入以便就地解密)
fn read_audio_segment(input: &Path, audio_len: u64) -> Result<Vec<u8>, DecryptError> {
use std::io::Read;
let mut f = std::fs::File::open(input)?;
let mut buf = vec![0u8; audio_len as usize];
f.read_exact(&mut buf)?;
Ok(buf)
}
/// 在**当前线程**上跑一个最小 tokio 运行时。
///
/// 调度层用独立 `std::thread` 干活,所以这里 `block_on` 是安全的
/// (不会在 tokio 的 worker 线程里嵌套)。
fn block_on<F: std::future::Future>(fut: F) -> F::Output {
match tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
{
Ok(rt) => rt.block_on(fut),
Err(_) => {
// 极端情况下退化为全局运行时(项目里已有 rt-multi-thread)
tauri::async_runtime::block_on(fut)
}
}
}
async fn fetch_ekey_async(
client: &reqwest::Client,
req: &EvkeyRequest,
) -> Result<(String, i64), DecryptError> {
qq_ekey::fetch_ekey(client, req).await
}
#[cfg(test)]
mod tests {
use super::*;
/// 状态探测必须能跑通且文案自洽(不假设本机 QQ 是否开着)
#[test]
fn probe_status_is_self_consistent() {
let s = probe_status();
assert_eq!(s.ready, s.running && s.logged_in);
assert!(!s.message.is_empty());
assert!(!s.steps.is_empty());
if s.ready {
assert!(s.steps.len() == 1, "就绪时只应给一条说明");
} else {
assert!(s.steps.len() >= 3, "未就绪时步骤要能照做");
}
}
/// 把本机真实探测结果打出来,便于人工核对「在线能力」是否按预期工作。
/// 不加断言(依赖本机是否开着 QQ 音乐),只在 `--nocapture` 时可见。
#[test]
fn probe_status_reports_machine_state() {
let s = probe_status();
eprintln!(
"[qq-online] running={} logged_in={} uin={:?} ready={}\n message: {}\n steps: {}",
s.running,
s.logged_in,
s.uin,
s.ready,
s.message,
s.steps.len()
);
}
/// musicex 文件必须被**离线路径**判为「需要密钥」,并且在有凭据时被识别为
/// 「该走在线路径」。
///
/// 刻意**不**真的发网络请求:单元测试不该依赖 QQ 服务器可达性与账号状态,
/// 否则本机登录后测试就会变慢、变脆。
#[test]
fn musicex_routes_to_online_path() {
let dir = std::env::temp_dir().join(format!("qq_online_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
// 造一个 musicex 文件:尾部合法(含 media_mid / filename)。
// 音频段的内容无所谓——这条只验证"路由与入参构造",不发网络请求。
let mut file = vec![0u8; 4096];
let n = file.len();
let tail_start = n - qq_footer::MUSICEX_FOOTER_LEN;
write_utf16(
&mut file[tail_start + 0x0C..tail_start + 0x0C + 60],
"0012ABCDEF",
);
write_utf16(
&mut file[tail_start + 0x48..tail_start + 0x48 + 68],
"O4M00012ABCDEF.mgg",
);
file[n - 16..n - 12].copy_from_slice(&(qq_footer::MUSICEX_FOOTER_LEN as u32).to_le_bytes());
file[n - 12..n - 8].copy_from_slice(&1u32.to_le_bytes());
file[n - 8..].copy_from_slice(qq_footer::MUSICEX_MAGIC);
let src = dir.join("a.mgg");
std::fs::write(&src, &file).unwrap();
// 1) 尾部能被解析出取密钥所需的两个字段
let tail = read_musicex_tail(&src).expect("尾部应解析成功");
assert_eq!(tail.media_mid, "0012ABCDEF");
assert_eq!(tail.filename, "O4M00012ABCDEF.mgg");
assert_eq!(tail.audio_len(file.len() as u64), (tail_start) as u64);
// 2) 离线路径必须明确报「需要密钥」,而不是解出噪声
let offline = super::super::qmc::sniff_tail(&src).unwrap();
assert_eq!(offline.kind, super::super::qmc::TailKind::MusiCex);
// 3) 请求能从尾部正确构造(这正是联网那一步的入参)
let req = EvkeyRequest::from_tail(&tail, "1154027699", "TOKEN").unwrap();
assert_eq!(req.media_mid, "0012ABCDEF");
assert_eq!(req.filename, "O4M00012ABCDEF.mgg");
let _ = std::fs::remove_dir_all(&dir);
}
/// 密钥错误时不应产出"看起来成功"的垃圾:
/// 判据是**解密结果**能否识别成已知音频魔术。
///
/// 这条同时固化一个真机结论:QMC2 的**密文头没有稳定魔术**
/// (真机 musicex 样本头为 `51 74 03 75`,而 MIT/Apache 文档里提到的
/// `#!Qk` 并不适用于它),所以**不能**用密文头做守卫。
#[test]
fn wrong_key_yields_unrecognizable_header() {
// 用一段随机数据当"密文",配一个随便的密钥
let mut data = vec![0x51u8, 0x74, 0x03, 0x75];
data.extend((0..4092).map(|i| (i * 7 % 251) as u8));
let key: Vec<u8> = (0..64).map(|i| (i * 3 + 1) as u8).collect();
super::super::qmc::decrypt_with_raw_key(&key, &mut data);
// 解出来必须是"认不出",才会走到 KeyRequired 那条错误分支
assert!(
super::super::common::detect_format_opt(&data).is_none(),
"随机数据不应被识别成音频"
);
}
/// `#!Qk` 是 QMC2 的一种形态,但**不是** musicex 的头部——这里留一条记录性断言,
/// 防止后人再次把它当成通用守卫。
#[test]
fn qmc2_ciphertext_header_is_not_a_reliable_magic() {
assert_ne!(b"#!Qk", &[0x51u8, 0x74, 0x03, 0x75]);
// 真机样本的头就是后者;`detect_format_opt` 对两者都不应误判成音频
assert!(super::super::common::detect_format_opt(b"#!Qk\x00\x00\x00\x00").is_none());
}
/// 把一个定长 UTF-16LE 字段写进缓冲区(测试辅助)
fn write_utf16(dst: &mut [u8], s: &str) {
for (i, unit) in s.encode_utf16().enumerate() {
let at = i * 2;
if at + 2 > dst.len() {
break;
}
dst[at..at + 2].copy_from_slice(&unit.to_le_bytes());
}
}
}
+249
View File
@@ -0,0 +1,249 @@
//! 文件夹批量:递归扫描 + 平台路由。
//!
//! 用户要的是「以文件夹为单位处理」,所以这里的判定原则是:
//!
//! 1. **内容优先于后缀**。同一个曲库里 `.ncm` / `.mflac` / `.qmcflac` / `.mgg` 混放是常态,
//! 而后者还有 `.mgg0`、`.mflac0` 这类后缀变体;靠后缀枚举会漏。
//! 因此先看头部魔数(网易云 `CTENFDAM`),再看尾部形态(QMC 家族)。
//! 2. **只扫一次、只走一层递归**。目录树遍历用 `walkdir`,过滤在遍历中完成,
//! 不把整个目录列表灌进内存(几万首的曲库会很难看)。
//! 3. 扫描结果按**路径排序**,保证同一目录每次处理的顺序稳定(进度条与任务表可预期)。
use std::path::{Path, PathBuf};
use walkdir::WalkDir;
use super::{ncm, qmc};
/// 一个待处理的文件
#[derive(Debug, Clone)]
pub struct ScannedFile {
/// 绝对路径
pub path: PathBuf,
/// 相对扫描根的父目录(用于在输出目录里还原目录结构);根目录下的文件为 None
pub rel_parent: Option<PathBuf>,
/// 文件名(含后缀),给 UI 显示
pub name: String,
/// 该用哪个引擎
pub engine: Engine,
}
/// 引擎路由结果
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Engine {
/// 网易云 ncm
Ncm,
/// QQ音乐 QMC 家族
Qmc,
}
impl Engine {
pub fn label(self) -> &'static str {
match self {
Engine::Ncm => "网易云",
Engine::Qmc => "QQ音乐",
}
}
}
/// 单文件路由:读 8 字节魔数 + 4KB 尾部即可判定,不做全文件读。
///
/// 返回 `None` 表示这个文件不是我们认得的加密音乐(目录扫描时直接跳过,
/// 用户显式选中的文件则会得到一条 `unsupported` 结果)。
pub fn route(path: &Path) -> Option<Engine> {
if ncm::sniff(path) {
return Some(Engine::Ncm);
}
// QMC:尾部能判出形态就算认得
if qmc::sniff_tail(path).is_ok() {
// 后缀也在 QMC 家族里、或尾部形态明确(非纯 QMC1 兜底)时才算
let ext = path
.extension()
.map(|e| e.to_string_lossy().to_string())
.unwrap_or_default();
if qmc::is_qmc_extension(&ext) {
return Some(Engine::Qmc);
}
// 后缀不认识时,只有明确的尾部形态(QTag/V1/musicex)才认;
// 否则任何末尾凑巧不是 QTag 的文件都会被判成"QMC1",噪声太大。
if let Ok(tail) = qmc::sniff_tail(path) {
if tail.kind != qmc::TailKind::Qmc1 {
return Some(Engine::Qmc);
}
}
}
None
}
/// 递归扫描 `folder`,返回所有可解密的加密音乐文件。
///
/// `root` 用于计算相对路径(输出时还原目录结构)。`folder == root` 时即
/// 「以这个文件夹为单位处理」。传 `root = None` 则所有文件平铺。
///
/// 排序保证稳定;`max_depth` 为 `None` 时递归全部层级。
pub fn scan(folder: &Path, root: Option<&Path>) -> Result<Vec<ScannedFile>, String> {
if !folder.is_dir() {
return Err(format!("{} 不是文件夹", folder.display()));
}
let root = root.unwrap_or(folder);
let mut out = Vec::new();
for entry in WalkDir::new(folder)
.follow_links(false)
.into_iter()
.filter_map(|e| e.ok())
{
if !entry.file_type().is_file() {
continue;
}
let path = entry.path();
let Some(engine) = route(path) else {
continue;
};
let rel_parent = path
.parent()
.and_then(|p| p.strip_prefix(root).ok())
.filter(|p| !p.as_os_str().is_empty())
.map(|p| p.to_path_buf());
let name = path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_else(|| path.display().to_string());
out.push(ScannedFile {
path: path.to_path_buf(),
rel_parent,
name,
engine,
});
}
// 稳定排序:按相对目录 + 文件名,处理顺序可预期
out.sort_by(|a, b| {
a.rel_parent
.cmp(&b.rel_parent)
.then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
});
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
fn tmpdir(tag: &str) -> PathBuf {
let d = std::env::temp_dir().join(format!("dec_scan_{tag}_{}", std::process::id()));
let _ = fs::remove_dir_all(&d);
fs::create_dir_all(&d).unwrap();
d
}
/// 构造一个最小合法 ncm 头(只需魔数即可被 route 认出来)
fn fake_ncm() -> Vec<u8> {
let mut v = b"CTENFDAM".to_vec();
v.extend_from_slice(&[0x02, 0x00, 0, 0, 0, 0]);
v
}
#[test]
fn route_detects_ncm_by_magic_not_extension() {
let dir = tmpdir("route");
// 后缀故意起错,内容是对的 → 应按内容识别
let p = dir.join("mystery.bin");
fs::write(&p, fake_ncm()).unwrap();
assert_eq!(route(&p), Some(Engine::Ncm));
// 后缀像 ncm 但内容不对 → 不应识别(尾部判成 QMC1 但后缀不在家族里)
let q = dir.join("wrong.ncm");
fs::write(&q, vec![0x11u8; 1024]).unwrap();
assert_eq!(route(&q), None);
let _ = fs::remove_dir_all(&dir);
}
/// QMC1 靠后缀识别(尾部形态是兜底,不做主判据)
#[test]
fn route_detects_qmc_by_extension() {
let dir = tmpdir("qmc");
let p = dir.join("a.qmcflac");
fs::write(&p, vec![0x22u8; 4096]).unwrap();
assert_eq!(route(&p), Some(Engine::Qmc));
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn scan_is_recursive_and_preserves_relative_dirs() {
let dir = tmpdir("scan");
fs::create_dir_all(dir.join("Pop").join("2026")).unwrap();
fs::create_dir_all(dir.join("Rock")).unwrap();
fs::write(dir.join("root.ncm"), fake_ncm()).unwrap();
fs::write(dir.join("Pop").join("a.qmcflac"), vec![0x22u8; 512]).unwrap();
fs::write(dir.join("Pop").join("2026").join("b.ncm"), fake_ncm()).unwrap();
fs::write(dir.join("Rock").join("c.txt"), b"not audio").unwrap();
let files = scan(&dir, Some(&dir)).unwrap();
assert_eq!(files.len(), 3, "应找到 3 个加密文件(txt 被跳过)");
// 排序稳定:先根目录,再 Pop,再 Pop/2026
assert_eq!(files[0].name, "root.ncm");
assert!(
files[0].rel_parent.is_none(),
"根目录文件 rel_parent 应为 None"
);
let a = files.iter().find(|f| f.name == "a.qmcflac").unwrap();
assert_eq!(a.rel_parent.as_deref(), Some(Path::new("Pop")));
assert_eq!(a.engine, Engine::Qmc);
let b = files.iter().find(|f| f.name == "b.ncm").unwrap();
assert_eq!(
b.rel_parent.as_deref(),
Some(Path::new("Pop").join("2026").as_path())
);
assert_eq!(b.engine, Engine::Ncm);
let _ = fs::remove_dir_all(&dir);
}
/// 以子目录为根时,相对路径相对**子目录**而不是父目录
#[test]
fn scan_uses_given_root_for_relative_paths() {
let dir = tmpdir("root");
let sub = dir.join("Album");
fs::create_dir_all(sub.join("Disc1")).unwrap();
fs::write(sub.join("Disc1").join("x.qmc0"), vec![0x33u8; 512]).unwrap();
// 以子目录为 root:Disc1 在 root 内 → rel_parent = Disc1
let files = scan(&sub, Some(&sub)).unwrap();
assert_eq!(files.len(), 1);
assert_eq!(files[0].rel_parent.as_deref(), Some(Path::new("Disc1")));
// 以上级为 root:rel_parent = Album/Disc1
let files2 = scan(&sub, Some(&dir)).unwrap();
assert_eq!(
files2[0].rel_parent.as_deref(),
Some(Path::new("Album").join("Disc1").as_path())
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn scan_rejects_non_directory() {
let dir = tmpdir("notdir");
let f = dir.join("a.txt");
fs::write(&f, b"x").unwrap();
assert!(scan(&f, None).is_err());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn scan_on_empty_dir_returns_empty() {
let dir = tmpdir("empty");
let files = scan(&dir, None).unwrap();
assert!(files.is_empty());
let _ = fs::remove_dir_all(&dir);
}
}
+54
View File
@@ -19,7 +19,9 @@
mod audio; mod audio;
mod bridge; mod bridge;
mod commands; mod commands;
pub mod decrypt;
mod feiniu; mod feiniu;
mod remote;
mod runtime; mod runtime;
mod secrets; mod secrets;
mod smtc; mod smtc;
@@ -33,6 +35,12 @@ pub use feiniu::{
extract_fn_id, normalize_base_url, resolve_base_url, scan_local_dirs, Feiniu, FeiniuConnection, extract_fn_id, normalize_base_url, resolve_base_url, scan_local_dirs, Feiniu, FeiniuConnection,
}; };
pub use remote::{
init_on_launch, remote_cancel_pairing, remote_get_config, remote_list_devices,
remote_publish_queue, remote_revoke_device, remote_set_enabled, remote_start_pairing,
remote_status, RemoteManager,
};
pub use smtc::{ pub use smtc::{
music_smtc_clear, music_smtc_update_metadata, music_smtc_update_playback_state, music_smtc_clear, music_smtc_update_metadata, music_smtc_update_playback_state,
music_smtc_update_position, SmtcController, music_smtc_update_position, SmtcController,
@@ -51,6 +59,10 @@ pub use commands::{
webdav_save_secret, webdav_test, webdav_upload, webdav_save_secret, webdav_test, webdav_upload,
}; };
pub use decrypt::commands::{
music_decrypt_cancel, music_decrypt_qq_status, music_decrypt_run, music_decrypt_scan,
};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use specta::Type; use specta::Type;
use std::collections::HashMap; use std::collections::HashMap;
@@ -126,6 +138,23 @@ pub struct MusicInstallProgress {
pub message: String, pub message: String,
} }
/// 前端最近一次推给 SMTC 的曲目信息(`music_smtc_update_metadata` 回填)。
///
/// 用途:**手机遥控的兜底聚合**——GSMTC 不可用时,`AudioEngine.state()` 只有
/// 位置/播放态没有标题/歌手(队列元数据在前端 feiniuStore),故以本缓存补全
/// (MUSIC_REMOTE_PLAN §5.2)。
#[derive(Default)]
pub struct SmtcMetaCache(pub Mutex<SmtcMetaSnapshot>);
/// [`SmtcMetaCache`] 的内容(字段与 `music_smtc_update_metadata` 命令对齐)。
/// cover_url 暂不存:兜底聚合的封面策略是 None(GSMTC 主路径自带缩略图,§5.2)。
#[derive(Default, Clone)]
pub struct SmtcMetaSnapshot {
pub title: String,
pub artist: String,
pub album: String,
}
/// 音乐模块设置(settings.json 持久化;变更即时生效) /// 音乐模块设置(settings.json 持久化;变更即时生效)
#[derive(Serialize, Deserialize, Clone, Type)] #[derive(Serialize, Deserialize, Clone, Type)]
#[serde(rename_all = "camelCase")] #[serde(rename_all = "camelCase")]
@@ -191,6 +220,18 @@ pub struct MusicSettings {
/// 下载完成后自动上传到飞牛曲库 /// 下载完成后自动上传到飞牛曲库
#[serde(default)] #[serde(default)]
pub feiniu_auto_upload: bool, pub feiniu_auto_upload: bool,
/// 手机互联:总开关(变更即时生效,MUSIC_REMOTE_PLAN §5.1)
#[serde(default)]
pub remote_enabled: bool,
/// 手机互联:期望端口(0 = 默认 26124 起自动探测至 26139)
#[serde(default)]
pub remote_port: u16,
/// 本机标识(beacon / NowPlaying.deviceId 同源;首次启动自动生成)
#[serde(default)]
pub remote_device_id: String,
/// 已配对设备表(仅元数据;token 在系统凭据管理器 `music-remote-token-*`)
#[serde(default)]
pub remote_devices: Vec<remote::RemoteDeviceMeta>,
} }
impl MusicSettings { impl MusicSettings {
@@ -311,6 +352,9 @@ pub struct MusicManager {
feiniu: Feiniu, feiniu: Feiniu,
/// AppHandle(桥接 reader 线程据此将事件转发给前端;setup 时设置) /// AppHandle(桥接 reader 线程据此将事件转发给前端;setup 时设置)
app: Mutex<Option<AppHandle>>, app: Mutex<Option<AppHandle>>,
/// 本地解密任务表(「解密」页签)。放这里而不是单独 `manage`,
/// 是为了让解密命令与其余音乐命令一样只取 `State<'_, MusicManager>`。
decrypt: Arc<decrypt::DecryptTasks>,
} }
impl MusicManager { impl MusicManager {
@@ -337,9 +381,15 @@ impl MusicManager {
settings_cache: Mutex::new(None), settings_cache: Mutex::new(None),
feiniu, feiniu,
app: Mutex::new(None), app: Mutex::new(None),
decrypt: Arc::new(decrypt::DecryptTasks::new()),
} }
} }
/// 解密任务表(供 `music/decrypt/commands.rs` 取用)
pub(crate) fn decrypt_tasks(&self) -> Arc<decrypt::DecryptTasks> {
self.decrypt.clone()
}
/// 设置 AppHandle(setup 阶段调用;桥接 reader 线程据此转发事件到前端) /// 设置 AppHandle(setup 阶段调用;桥接 reader 线程据此转发事件到前端)
pub fn set_app(&self, app: AppHandle) { pub fn set_app(&self, app: AppHandle) {
if let Ok(mut guard) = self.app.lock() { if let Ok(mut guard) = self.app.lock() {
@@ -385,6 +435,10 @@ impl MusicManager {
feiniu_play_mode: "stream".to_string(), feiniu_play_mode: "stream".to_string(),
feiniu_library_nas_path: String::new(), feiniu_library_nas_path: String::new(),
feiniu_auto_upload: false, feiniu_auto_upload: false,
remote_enabled: false,
remote_port: 0,
remote_device_id: String::new(),
remote_devices: Vec::new(),
} }
} }
+181
View File
@@ -0,0 +1,181 @@
//! 设备发现:UDP beacon(MUSIC_REMOTE_PLAN §3.3,P0 主路径)。
//!
//! 电脑每 3s 向 `255.255.255.255:26123` **与各网卡的定向广播地址**发 JSON 包;
//! 手机被动监听 26123 收集。beacon 不含任何敏感信息(无 token、无配对码)。
//!
//! 各网卡定向广播是必须的:本机常驻 VPN/虚拟网卡(mihomo 等),默认路由可能
//! 不在 LAN 网卡上,仅发 255.255.255.255 会从默认路由出去、手机收不到(§8 风险行
//! "多网卡/VPN 虚拟网卡"的对策)。地址枚举走 `GetAdaptersAddresses`。
use std::net::{Ipv4Addr, UdpSocket};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::thread::JoinHandle;
use std::time::Duration;
/// 手机监听的 beacon 端口(与 LFMusic `bind :26123` 对齐)。
pub const BEACON_PORT: u16 = 26123;
/// beacon 广播周期(与对端文档 §5.1"每 3s 广播"对齐)。
const BEACON_INTERVAL: Duration = Duration::from_secs(3);
/// beacon 负载(§3.3)。`addrs` 供手机在多地址场景按连通性优选(§8 对策)。
#[derive(Clone, serde::Serialize)]
pub struct BeaconPayload {
pub service: &'static str,
#[serde(rename = "deviceId")]
pub device_id: String,
pub name: String,
pub port: u16,
#[serde(rename = "protoVer")]
pub proto_ver: u32,
/// 本机各网卡 IPv4(去重、去回环、去 169.254 链路本地)
pub addrs: Vec<String>,
}
/// 枚举本机可用的 IPv4 与对应定向广播地址(网段广播,prefix<32 才有)。
///
/// 失败时返回空(beacon 退化为只发 255.255.255.255,不阻断启动)。
#[cfg(windows)]
pub fn ipv4_broadcast_pairs() -> Vec<(Ipv4Addr, Ipv4Addr)> {
use windows::Win32::NetworkManagement::IpHelper::{
GAA_FLAG_INCLUDE_PREFIX, GAA_FLAG_SKIP_ANYCAST, GAA_FLAG_SKIP_DNS_SERVER,
GAA_FLAG_SKIP_MULTICAST, GetAdaptersAddresses, IP_ADAPTER_ADDRESSES_LH,
IP_ADAPTER_UNICAST_ADDRESS_LH,
};
use windows::Win32::Networking::WinSock::{AF_INET, SOCKADDR_IN};
let mut out: Vec<(Ipv4Addr, Ipv4Addr)> = Vec::new();
unsafe {
let mut size: u32 = 0;
let flags = GAA_FLAG_INCLUDE_PREFIX
| GAA_FLAG_SKIP_ANYCAST
| GAA_FLAG_SKIP_MULTICAST
| GAA_FLAG_SKIP_DNS_SERVER;
// 第一次调用只探长度(返回 ERROR_BUFFER_OVERFLOW = 111)
let _ = GetAdaptersAddresses(AF_INET.0 as u32, flags, None, None, &mut size);
if size == 0 {
return out;
}
let mut buf = vec![0u8; size as usize];
let ptr = buf.as_mut_ptr() as *mut IP_ADAPTER_ADDRESSES_LH;
let ret = GetAdaptersAddresses(AF_INET.0 as u32, flags, None, Some(ptr), &mut size);
if ret != 0 {
crate::logger::log_warn(
"music-remote",
&format!("GetAdaptersAddresses 失败: {ret}(beacon 退化为受限广播)"),
);
return out;
}
let mut adapter = (*ptr).FirstUnicastAddress;
while !adapter.is_null() {
let ua: *mut IP_ADAPTER_UNICAST_ADDRESS_LH = adapter;
let sa = (*ua).Address;
let sockaddr = sa.lpSockaddr as *const SOCKADDR_IN;
if !sockaddr.is_null() {
let raw = u32::from_be((*sockaddr).sin_addr.S_un.S_addr);
let ip = Ipv4Addr::from(raw);
// 跳过回环与链路本地(APIPA)
if !ip.is_loopback() && !ip.is_link_local() {
let prefix = (*ua).OnLinkPrefixLength.min(32);
if prefix == 0 {
out.push((ip, Ipv4Addr::BROADCAST));
} else {
let mask = u32::MAX << (32 - prefix);
let bcast = Ipv4Addr::from(raw | !mask);
if bcast != ip && !bcast.is_loopback() {
out.push((ip, bcast));
} else {
out.push((ip, Ipv4Addr::BROADCAST));
}
}
}
}
adapter = (*ua).Next;
}
}
// 去重(多网卡同地址 / 多地址同广播)
let mut seen = std::collections::HashSet::new();
out.retain(|p| seen.insert(*p));
out
}
#[cfg(not(windows))]
pub fn ipv4_broadcast_pairs() -> Vec<(Ipv4Addr, Ipv4Addr)> {
Vec::new()
}
/// 取一个适合放进二维码 payload 的本机 LAN IP(首个非链路本地 IPv4)。
pub fn primary_ipv4() -> Option<Ipv4Addr> {
ipv4_broadcast_pairs()
.into_iter()
.map(|(ip, _)| ip)
.find(|ip| !ip.is_loopback() && !ip.is_link_local())
}
/// 启动 beacon 广播线程;`shutdown` 置 true 后最迟一个周期内退出。
pub fn spawn_beacon(payload: BeaconPayload, shutdown: Arc<AtomicBool>) -> JoinHandle<()> {
std::thread::Builder::new()
.name("remote-beacon".to_string())
.spawn(move || {
let sock = match UdpSocket::bind("0.0.0.0:0") {
Ok(s) => s,
Err(e) => {
crate::logger::log_error(
"music-remote",
&format!("beacon 套接字绑定失败: {e}"),
);
return;
}
};
let _ = sock.set_broadcast(true);
let json = serde_json::to_string(&payload).unwrap_or_default();
let bytes = json.as_bytes();
crate::logger::log_info(
"music-remote",
&format!(
"beacon 已启动 → :{BEACON_PORT},addrs={:?},payload={json}",
payload.addrs
),
);
while !shutdown.load(Ordering::Relaxed) {
// 受限广播(默认路由 NIC)
let _ = sock.send_to(bytes, ("255.255.255.255", BEACON_PORT));
// 各网卡定向广播(VPN/多网卡场景的保底路径)
for (_, bcast) in ipv4_broadcast_pairs() {
let _ = sock.send_to(bytes, (bcast, BEACON_PORT));
}
for _ in 0..(BEACON_INTERVAL.as_millis() / 100).max(1) {
if shutdown.load(Ordering::Relaxed) {
break;
}
std::thread::sleep(Duration::from_millis(100));
}
}
crate::logger::log_info("music-remote", "beacon 已停止");
})
.expect("创建 beacon 线程失败")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn payload_shape_matches_phone_expectation() {
let p = BeaconPayload {
service: "thing-music",
device_id: "d1".into(),
name: "Thing".into(),
port: 26124,
proto_ver: 1,
addrs: vec!["192.168.1.5".into()],
};
let json = serde_json::to_string(&p).unwrap();
// 手机端按 service 过滤、按 deviceId 去重(LFMusic §5.1)
assert!(json.contains("\"service\":\"thing-music\""));
assert!(json.contains("\"deviceId\":\"d1\""));
assert!(json.contains("\"protoVer\":1"));
assert!(json.contains("\"port\":26124"));
}
}
+828
View File
@@ -0,0 +1,828 @@
//! GSMTC 全局会话监视与控制(MUSIC_REMOTE_PLAN §3.1 / §5.1 `glsmtc.rs`)。
//!
//! # 线程模型(§3.1,实测修订版)
//!
//! - 监视跑在**专用线程**(`remote-gsmtc`):该线程首次 WinRT 调用即按 MTA 初始化,
//! `RequestAsync().get()` 等阻塞等待全部发生在本线程——既满足"`.get()` 不在主线程"
//! 的 STA 死锁约束,也不需要像 `smtc.rs` 那样把发起抛回主线程(GSMTC 不绑窗口,
//! 无 HWND 交互)。事件订阅也在本线程完成;回调从线程池触发,对象 agile,直接读写。
//! - 控制(`Try*Async.get`)由 server 在 `spawn_blocking` 里调 [`control`]。
//!
//! # 节流(§6.3)
//!
//! 事件风暴合并后**最快 1Hz** 发布 `state`;进度靠手机本地推算。例外:`Force`
//! (cmd 触发)立即发布一帧,绕过节流。语义变化(歌/状态/会话)不等节流窗口。
//!
//! # 失败策略(§3.1)
//!
//! GSMTC 任何失败只记日志;初始化失败 → `gsmtc_ok=false`,聚合切换到
//! AudioEngine + SmtcMetaCache 兜底(§5.2)。
use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use tauri::{AppHandle, Manager};
use tokio::sync::watch;
use windows::Foundation::TypedEventHandler;
use windows::Media::Control::{
CurrentSessionChangedEventArgs, GlobalSystemMediaTransportControlsSession as GsSession,
GlobalSystemMediaTransportControlsSessionManager as GsManager,
GlobalSystemMediaTransportControlsSessionMediaProperties as GsMediaProperties,
GlobalSystemMediaTransportControlsSessionPlaybackStatus as GsStatus,
MediaPropertiesChangedEventArgs, PlaybackInfoChangedEventArgs, SessionsChangedEventArgs,
TimelinePropertiesChangedEventArgs,
};
use super::proto::{
self, CanControl, CmdAction, CmdArgs, NowPlaying, PlayStatus, THING_SELF_SESSION,
};
use super::volume;
use super::CoverStore;
use crate::music::{AudioEngine, MusicManager, SmtcMetaCache};
/// 100 纳秒 ticks/秒。
const TICKS_PER_SEC: i64 = 10_000_000;
/// 位置跳变阈值(秒):超过它就补发一帧。与手机端 `rebaseProgress` 的
/// 1.5s 判定一致——发出来的跳变一定能被手机端识别为「来源已更新」。
const POSITION_JUMP_SEC: f64 = 1.5;
/// 封面读取上限(防异常大图)。
const MAX_COVER_BYTES: u32 = 10 * 1024 * 1024;
/// 监视线程消息。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MonitorMsg {
/// 事件到达(合并处理)
Change,
/// cmd 后立即发布(绕过 1Hz 节流,§6.3 例外)
Force,
/// 退出
Stop,
}
/// GSMTC 监视器句柄(RemoteManager 持有)。
pub struct GsmtcMonitor {
tx: Sender<MonitorMsg>,
handle: Mutex<Option<std::thread::JoinHandle<()>>>,
}
impl GsmtcMonitor {
#[allow(clippy::too_many_arguments)]
pub fn start(
app: AppHandle,
state_tx: Arc<watch::Sender<NowPlaying>>,
covers: Arc<CoverStore>,
gsmtc_ok: Arc<AtomicBool>,
sessions_tx: Arc<watch::Sender<Vec<proto::SessionInfo>>>,
selected: Arc<Mutex<Option<String>>>,
) -> Self {
let (tx, rx) = mpsc::channel::<MonitorMsg>();
let thread_tx = tx.clone();
let handle = std::thread::Builder::new()
.name("remote-gsmtc".to_string())
.spawn(move || {
run(
app, state_tx, covers, gsmtc_ok, sessions_tx, selected, thread_tx, rx,
)
})
.expect("创建 gsmtc 监视线程失败");
Self {
tx,
handle: Mutex::new(Some(handle)),
}
}
pub fn send(&self, msg: MonitorMsg) {
let _ = self.tx.send(msg);
}
pub fn notify_force(&self) {
self.send(MonitorMsg::Force);
}
/// 停止并等待线程退出(先 Stop 唤醒,join 最迟在下一次 500ms 节拍内完成)。
pub fn stop(&self) {
self.send(MonitorMsg::Stop);
let handle = self
.handle
.lock()
.unwrap_or_else(|e| e.into_inner())
.take();
if let Some(h) = handle {
let _ = h.join();
}
}
}
impl Drop for GsmtcMonitor {
fn drop(&mut self) {
self.send(MonitorMsg::Stop);
}
}
// ---------------------------------------------------------------------------
// 聚合(监视线程)
// ---------------------------------------------------------------------------
/// 语义指纹:不含 position/updatedAt(它们每秒都变,单独走进度窗口)。
fn fingerprint(np: &NowPlaying) -> String {
// 引用 + 元组整体 Debug:避开逐字段 format 的 Display/Debug 混用与 move 错误
format!(
"{:?}",
(
&np.session_id,
&np.source_app,
np.is_thing,
&np.title,
&np.artist,
&np.album,
&np.cover_hash,
np.status,
np.duration_sec,
&np.can_control,
np.volume,
np.muted,
)
)
}
fn run(
app: AppHandle,
state_tx: Arc<watch::Sender<NowPlaying>>,
covers: Arc<CoverStore>,
gsmtc_ok: Arc<AtomicBool>,
sessions_tx: Arc<watch::Sender<Vec<proto::SessionInfo>>>,
selected: Arc<Mutex<Option<String>>>,
tx: Sender<MonitorMsg>,
rx: Receiver<MonitorMsg>,
) {
// 首次 WinRT 调用在此线程自动按 MTA 初始化(见模块注释)
// RequestAsync() → Result<IAsyncOperation<_>>;外层 Result 与异步 get() 分两步
let manager = GsManager::RequestAsync().and_then(|op| op.get());
match &manager {
Ok(_) => {
gsmtc_ok.store(true, Ordering::Relaxed);
crate::logger::log_info("music-remote", "GSMTC 已初始化(专用线程 MTA)");
}
Err(e) => {
gsmtc_ok.store(false, Ordering::Relaxed);
crate::logger::log_error(
"music-remote",
&format!("GSMTC 初始化失败,远程查看/控制降级为「仅 Thing 自身」: {e}"),
);
}
}
// 事件订阅:任一变更 → Change(合并节流在下方发布逻辑里)
if let Ok(m) = &manager {
let t = tx.clone();
let _ = m.CurrentSessionChanged(
&TypedEventHandler::<GsManager, CurrentSessionChangedEventArgs>::new(move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
}),
);
let t = tx.clone();
let _ = m.SessionsChanged(
&TypedEventHandler::<GsManager, SessionsChangedEventArgs>::new(move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
}),
);
// 说明:MediaProperties/Timeline/PlaybackInfo 是 **Session 级**事件(挂在每条会话上,
// 需随会话变化反复订阅/退订)。P0 简化为不订阅——聚合本身以 500ms 节拍轮询,
// 语义变化最多延迟 ~500ms 上屏(发布规则见下),1Hz 进度窗口不受影响;
// 会话级事件的精细化订阅列入 P1(计划 §7)。
}
let mut last_publish: Option<Instant> = None;
let mut last_fp = String::new();
// 上次**发布**时的位置:位置不进语义指纹(每秒都变),单独用来识别跳变
let mut last_pos: Option<f64> = None;
// 封面快捷缓存:coverKey → hash(避免同曲反复读缩略图;字节在 CoverStore)
let mut cover_local: HashMap<String, String> = HashMap::new();
// AUMID → 显示名缓存(注册表友好名,P1 §7)
let mut name_cache: HashMap<String, String> = HashMap::new();
// 会话列表指纹(变化才推 sessions 消息)
let mut last_sessions_fp = String::new();
// 当前目标会话的事件订阅(P1 §7 会话级事件:随目标切换订阅/退订)
let mut subs: Option<SessionSubs> = None;
let mut last_sub_aumid = String::new();
loop {
// 收一轮消息(风暴合并)
let mut force = false;
let mut running = true;
match rx.recv_timeout(Duration::from_millis(500)) {
Ok(MonitorMsg::Stop) => running = false,
Ok(MonitorMsg::Force) => force = true,
Ok(MonitorMsg::Change) => {}
Err(RecvTimeoutError::Timeout) => {}
Err(RecvTimeoutError::Disconnected) => running = false,
}
while running {
match rx.try_recv() {
Ok(MonitorMsg::Stop) => {
running = false;
break;
}
Ok(MonitorMsg::Force) => force = true,
Ok(MonitorMsg::Change) => {}
Err(_) => break,
}
}
if !running {
break;
}
// 设置读取:remote_device_id(MusicManager 500ms 缓存,开销可忽略)
let device_id = app
.try_state::<MusicManager>()
.map(|m| m.load_settings().remote_device_id)
.unwrap_or_default();
// 目标会话:手机选中覆盖优先,否则系统 current(P1 多会话切换;
// WinRT 无 SetCurrentSession,选中是 Thing 侧覆盖而非改系统判定)
let (target, needs_clear) = match &manager {
Ok(m) => {
let sel = selected
.lock()
.map(|g| g.clone())
.unwrap_or_default();
pick_target(m, sel.as_deref())
}
Err(_) => (None, false),
};
if needs_clear {
if let Ok(mut s) = selected.lock() {
s.take();
}
}
// 会话级事件订阅跟随目标(P1 §7:Media/Timeline/PlaybackInfo 随会话退订换绑)
if manager.is_ok() {
let aumid = target
.as_ref()
.and_then(|s| s.SourceAppUserModelId().ok())
.map(|h| h.to_string())
.unwrap_or_default();
if aumid != last_sub_aumid {
if let Some(old) = subs.take() {
old.remove_all();
}
if let Some(t) = &target {
subs = Some(SessionSubs::subscribe(t, &tx));
}
last_sub_aumid = aumid;
}
}
// 系统主音量轮询(P1 §7;500ms 一次,端点不可用时 volume=None)
let (vol, muted) = volume::read().map(|(v, m)| (Some(v), m)).unwrap_or((None, false));
let mut np = if manager.is_err() {
aggregate_fallback(&app, &device_id)
} else if let Some(sess) = &target {
aggregate_session(&app, sess, &device_id, &covers, &mut cover_local, &mut name_cache)
} else {
NowPlaying::stopped(&device_id)
};
np.volume = vol;
np.muted = muted;
// 会话列表(变化才推;连接时 watch 快照兜底)
if let Ok(m) = &manager {
let list = build_sessions(m, np.session_id.as_str(), &mut name_cache);
let fp_s = format!("{:?}", list);
if fp_s != last_sessions_fp {
last_sessions_fp = fp_s;
sessions_tx.send_replace(list);
}
}
let fp = fingerprint(&np);
let semantic = fp != last_fp;
let playing = np.status == PlayStatus::Playing;
let progress_due = last_publish
.map(|t| t.elapsed() >= Duration::from_secs(1))
.unwrap_or(true);
// 位置跳变(seek)单独发帧:`position` 不进指纹,暂停态又没有 1Hz 进度帧,
// 不补这一帧的话,手机端刚拖好的位置永远等不到来源确认
// (保持窗口到期后只能回退到旧位置,表现为「先保持再跳回去」)
let position_jump = last_pos
.map(|p| (np.position_sec - p).abs() > POSITION_JUMP_SEC)
.unwrap_or(false);
if force || semantic || position_jump || (playing && progress_due) {
last_publish = Some(Instant::now());
last_fp = fp;
last_pos = Some(np.position_sec);
// watch:无接收者时 send_replace 仍更新值(新客户端从 borrow 拿快照)
state_tx.send_replace(np);
}
}
if let Some(s) = subs.take() {
s.remove_all();
}
crate::logger::log_info("music-remote", "GSMTC 监视线程已退出");
}
/// 把目标会话聚合成 `NowPlaying`(§5.2 主路径;目标由 [`pick_target`] 选定)。
fn aggregate_session(
app: &AppHandle,
session: &GsSession,
device_id: &str,
covers: &CoverStore,
cover_local: &mut HashMap<String, String>,
name_cache: &mut HashMap<String, String>,
) -> NowPlaying {
let aumid = session
.SourceAppUserModelId()
.map(|h| h.to_string())
.unwrap_or_default();
let is_thing = proto::is_thing_aumid(&aumid);
// 元数据(§6.2 缩略图)
let props = session.TryGetMediaPropertiesAsync().and_then(|op| op.get());
let (title, artist, album) = match &props {
Ok(p) => (
p.Title().map(|h| h.to_string()).unwrap_or_default(),
p.Artist().map(|h| h.to_string()).unwrap_or_default(),
p.AlbumTitle().map(|h| h.to_string()).unwrap_or_default(),
),
Err(_) => (String::new(), String::new(), String::new()),
};
let cover_hash = props.as_ref().ok().and_then(|p| {
let key = format!("{aumid}|{title}|{album}");
cover_for(p, &key, covers, cover_local)
});
// 播放状态与能力位
let info = session.GetPlaybackInfo();
let status = match info.as_ref().ok().and_then(|i| i.PlaybackStatus().ok()) {
Some(GsStatus::Playing) => PlayStatus::Playing,
Some(GsStatus::Paused) => PlayStatus::Paused,
_ => PlayStatus::Stopped,
};
let can = match info.as_ref().ok().and_then(|i| i.Controls().ok()) {
// Thing 自身会话:控制走前端事件链直通(play/pause/next/prev/seek 全部可用),
// 不看 SMTC 的能力位——系统面板那套 IsXxxEnabled 里没有 seek 位,
// 照抄会把手机端的进度条锁成只读(seek 实际由 AudioEngine 直接处理)
Some(_) if is_thing => CanControl {
play: true,
pause: true,
next: true,
prev: true,
seek: true,
},
Some(c) => CanControl {
play: c.IsPlayEnabled().unwrap_or(false),
pause: c.IsPauseEnabled().unwrap_or(false),
next: c.IsNextEnabled().unwrap_or(false),
prev: c.IsPreviousEnabled().unwrap_or(false),
// WinRT 无 IsSeekEnabled,seek 能力位叫 IsPlaybackPositionEnabled
seek: c.IsPlaybackPositionEnabled().unwrap_or(false),
},
None if is_thing => CanControl {
play: true,
pause: true,
next: true,
prev: true,
seek: true,
},
None => CanControl {
play: false,
pause: false,
next: false,
prev: false,
seek: false,
},
};
// PlaybackRate 是 IReference<f64>(可空)→ Value() 解引用
let playback_rate = info
.as_ref()
.ok()
.and_then(|i| i.PlaybackRate().ok())
.and_then(|r| r.Value().ok())
.filter(|r| r.is_finite() && *r > 0.0)
.unwrap_or(1.0);
// 时间轴(§6.4:位置基准用 LastUpdatedTime)
let (position_sec, duration_sec, position_updated_at_ms) = match session.GetTimelineProperties()
{
Ok(tl) => {
let pos = tl
.Position()
.map(|t| t.Duration as f64 / TICKS_PER_SEC as f64)
.unwrap_or(0.0);
let dur = tl
.EndTime()
.map(|t| t.Duration as f64 / TICKS_PER_SEC as f64)
.unwrap_or(0.0);
// `LastUpdatedTime = 0` = 来源从未上报过时间轴(bilibili PC 实测:
// position=0 / EndTime=0 / LastUpdatedTime=0)。换算出的负值同样没有意义,
// 一律归 0 作「无进度基准」哨兵,手机端据此停掉进度推算(否则每秒一帧
// 从 0 起算,进度条原地抽搐)。
let updated = tl
.LastUpdatedTime()
.map(|d| proto::winrt_ticks_to_unix_ms(d.UniversalTime))
.unwrap_or(0);
(pos.max(0.0), dur.max(0.0), updated.max(0))
}
// 取不到时间轴 = 没有可用基准,不能拿本机时间伪装成"刚更新过"
Err(_) => (0.0, 0.0, 0),
};
// Thing 自身会话:位置改用 AudioEngine 快照。SMTC 那份由前端按 1s 节流上报、
// 暂停态甚至不刷新,手机端拖完 seek 会一直等不到「来源已到新位置」的确认,
// 保持窗口到期后只能回退到旧位置。引擎快照是逐次读取的权威值,seek 后立即反映。
let (position_sec, position_updated_at_ms) = if is_thing {
let engine_pos = app.try_state::<AudioEngine>().and_then(|e| {
let st = e.state();
st.active.then_some(st.position_sec)
});
match engine_pos {
Some(p) => (p.max(0.0), now_unix_ms()),
None => (position_sec, position_updated_at_ms), // 引擎无会话:退回 SMTC 值
}
} else {
(position_sec, position_updated_at_ms)
};
NowPlaying {
session_id: proto::session_key(&aumid),
source_app: friendly_name(&aumid, name_cache),
is_thing,
title,
artist,
album,
cover_hash,
status,
duration_sec,
position_sec,
position_updated_at_ms,
playback_rate,
can_control: can,
volume: None,
muted: false,
device_id: device_id.to_string(),
}
}
/// 读取会话缩略图 → 存 CoverStore → 返回 hash(§6.2:WS 只带 hash)。
fn cover_for(
props: &GsMediaProperties,
key: &str,
covers: &CoverStore,
local: &mut HashMap<String, String>,
) -> Option<String> {
if let Some(h) = local.get(key) {
return Some(h.clone());
}
// 无缩略图(null → Err)直接返回 None;同 key 不重试(记空串占位)
let reference = match props.Thumbnail() {
Ok(r) => r,
Err(_) => {
local.insert(key.to_string(), String::new());
return None;
}
};
let bytes = read_thumb(&reference)?;
let hash = covers.put(&bytes)?;
// 快捷缓存防膨胀(同曲重读的代价可接受)
if local.len() > 128 {
local.clear();
}
local.insert(key.to_string(), hash.clone());
Some(hash)
}
/// `IRandomAccessStreamReference` → 字节(DataReader 路径,无需 Cryptography feature)。
fn read_thumb(reference: &windows::Storage::Streams::IRandomAccessStreamReference) -> Option<Vec<u8>> {
use windows::Storage::Streams::DataReader;
let stream = reference.OpenReadAsync().ok()?.get().ok()?;
let size = stream.Size().ok()? as u32;
if size == 0 || size > MAX_COVER_BYTES {
return None;
}
let reader = DataReader::CreateDataReader(&stream).ok()?;
reader.LoadAsync(size).ok()?.get().ok()?;
let mut buf = vec![0u8; size as usize];
reader.ReadBytes(&mut buf).ok()?;
Some(buf)
}
/// 兜底聚合(§5.2:GSMTC 不可用时):AudioEngine 状态 + 前端已推送的 SMTC 元数据。
fn aggregate_fallback(app: &AppHandle, device_id: &str) -> NowPlaying {
let engine = match app.try_state::<AudioEngine>() {
Some(e) => e,
None => return NowPlaying::stopped(device_id),
};
let st = engine.state();
if !st.active {
return NowPlaying::stopped(device_id);
}
let meta = app
.try_state::<SmtcMetaCache>()
.map(|c| c.0.lock().unwrap_or_else(|e| e.into_inner()).clone())
.unwrap_or_default();
NowPlaying {
session_id: THING_SELF_SESSION.to_string(),
source_app: proto::source_display(proto::THING_AUMID),
is_thing: true,
title: meta.title,
artist: meta.artist,
album: meta.album,
cover_hash: None,
status: if st.playing {
PlayStatus::Playing
} else {
PlayStatus::Paused
},
position_sec: st.position_sec,
position_updated_at_ms: now_unix_ms(),
playback_rate: 1.0,
can_control: CanControl {
play: true,
pause: true,
next: true,
prev: true,
seek: true,
},
device_id: device_id.to_string(),
..NowPlaying::default()
}
}
fn now_unix_ms() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis() as i64)
.unwrap_or(0)
}
// ---------------------------------------------------------------------------
// 会话选择 / 列表 / 事件订阅 / 友好名(P1 §7)
// ---------------------------------------------------------------------------
/// 选定目标会话:`selected` 命中则用之;否则系统 current。
/// 返回 `(目标, 是否需要清除选中)`——选中项已消失时回退 current 并标记清除。
/// (WinRT **没有** SetCurrentSession:选中是 Thing 侧覆盖,不改系统判定。)
fn pick_target(manager: &GsManager, selected: Option<&str>) -> (Option<GsSession>, bool) {
if let Some(sid) = selected.filter(|s| !s.is_empty()) {
let mut found: Option<GsSession> = None;
if let Ok(list) = manager.GetSessions() {
for i in 0..list.Size().unwrap_or(0) {
if let Ok(s) = list.GetAt(i) {
let key = s
.SourceAppUserModelId()
.ok()
.map(|h| proto::session_key(&h.to_string()));
if key.as_deref() == Some(sid) {
found = Some(s);
break;
}
}
}
}
return match found {
Some(s) => (Some(s), false),
None => (manager.GetCurrentSession().ok(), true),
};
}
(manager.GetCurrentSession().ok(), false)
}
/// 枚举全部会话为手机端列表(`is_current` = 是否当前展示目标)。
fn build_sessions(
manager: &GsManager,
current_key: &str,
name_cache: &mut HashMap<String, String>,
) -> Vec<proto::SessionInfo> {
let Ok(list) = manager.GetSessions() else {
return Vec::new();
};
let mut out = Vec::new();
for i in 0..list.Size().unwrap_or(0) {
let Ok(s) = list.GetAt(i) else { continue };
let aumid = s
.SourceAppUserModelId()
.map(|h| h.to_string())
.unwrap_or_default();
let key = proto::session_key(&aumid);
let (title, artist) = match s.TryGetMediaPropertiesAsync().and_then(|op| op.get()) {
Ok(p) => (
p.Title().map(|h| h.to_string()).unwrap_or_default(),
p.Artist().map(|h| h.to_string()).unwrap_or_default(),
),
Err(_) => (String::new(), String::new()),
};
let status = match s.GetPlaybackInfo().and_then(|i| i.PlaybackStatus()) {
Ok(GsStatus::Playing) => PlayStatus::Playing,
Ok(GsStatus::Paused) => PlayStatus::Paused,
_ => PlayStatus::Stopped,
};
out.push(proto::SessionInfo {
is_current: key == current_key,
session_id: key,
source_app: friendly_name(&aumid, name_cache),
title,
artist,
status,
is_thing: proto::is_thing_aumid(&aumid),
});
}
out
}
/// 目标会话的三个事件订阅(P1 §7:随目标切换退订/换绑,唤醒聚合循环)。
struct SessionSubs {
session: GsSession,
tokens: Vec<(SubKind, windows::Foundation::EventRegistrationToken)>,
}
enum SubKind {
Props,
Timeline,
Info,
}
impl SessionSubs {
fn subscribe(sess: &GsSession, tx: &Sender<MonitorMsg>) -> Self {
let mut tokens = Vec::new();
// 三个事件的 args 类型各不相同,逐个构造 handler(不能复用闭包)
{
let t = tx.clone();
let h = TypedEventHandler::<GsSession, MediaPropertiesChangedEventArgs>::new(
move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
},
);
if let Ok(tok) = sess.MediaPropertiesChanged(&h) {
tokens.push((SubKind::Props, tok));
}
}
{
let t = tx.clone();
let h = TypedEventHandler::<GsSession, TimelinePropertiesChangedEventArgs>::new(
move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
},
);
if let Ok(tok) = sess.TimelinePropertiesChanged(&h) {
tokens.push((SubKind::Timeline, tok));
}
}
{
let t = tx.clone();
let h = TypedEventHandler::<GsSession, PlaybackInfoChangedEventArgs>::new(
move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
},
);
if let Ok(tok) = sess.PlaybackInfoChanged(&h) {
tokens.push((SubKind::Info, tok));
}
}
Self {
session: sess.clone(),
tokens,
}
}
fn remove_all(self) {
for (kind, tok) in self.tokens {
let r = match kind {
SubKind::Props => self.session.RemoveMediaPropertiesChanged(tok),
SubKind::Timeline => self.session.RemoveTimelinePropertiesChanged(tok),
SubKind::Info => self.session.RemovePlaybackInfoChanged(tok),
};
if let Err(e) = r {
crate::logger::log_warn("music-remote", &format!("退订会话事件失败: {e}"));
}
}
}
}
/// AUMID → 显示名:注册表友好名(`HKCU\\Software\\Classes\\AppUserModelId\\<aumid>`)
/// 缓存优先,查不到退回 AUMID 简化段(§6.7 P1)。
fn friendly_name(aumid: &str, cache: &mut HashMap<String, String>) -> String {
if let Some(v) = cache.get(aumid) {
return v.clone();
}
let name = if proto::is_thing_aumid(aumid) {
"Thing".to_string()
} else {
registry_display_name(aumid).unwrap_or_else(|| proto::source_display(aumid))
};
if cache.len() > 128 {
cache.clear();
}
cache.insert(aumid.to_string(), name.clone());
name
}
fn registry_display_name(aumid: &str) -> Option<String> {
// 路径形 AUMID(含反斜杠)无法作注册表单键名;空串跳过
if aumid.is_empty() || aumid.contains('\\') {
return None;
}
use winreg::RegKey;
use winreg::enums::HKEY_CURRENT_USER;
let key = RegKey::predef(HKEY_CURRENT_USER)
.open_subkey(format!(r"Software\Classes\AppUserModelId\{aumid}"))
.ok()?;
key.get_value::<String, _>("DisplayName")
.ok()
.filter(|s| !s.trim().is_empty())
}
// ---------------------------------------------------------------------------
// 控制(server 在 spawn_blocking 里调用)
// ---------------------------------------------------------------------------
/// 对指定会话执行控制动作(§3.1:统一走 GSMTC `Try*Async`)。
///
/// **阻塞**(`.get()` 等待 WinRT async):调用方必须在 `spawn_blocking` / 专用线程。
/// `session_id` 为 [`proto::NowPlaying::session_id`](控制"手机上正在显示的那条")。
pub fn control(session_id: &str, action: CmdAction, args: Option<CmdArgs>) -> Result<(), String> {
let manager = GsManager::RequestAsync()
.and_then(|op| op.get())
.map_err(|e| format!("GSMTC 不可用: {e}"))?;
let session = find_session(&manager, session_id)?;
// toggle 需要先读当前状态
let playing = matches!(
session.GetPlaybackInfo().and_then(|i| i.PlaybackStatus()),
Ok(GsStatus::Playing)
);
let op = match action {
CmdAction::Play => session.TryPlayAsync().map_err(err_of)?,
CmdAction::Pause => session.TryPauseAsync().map_err(err_of)?,
CmdAction::Toggle => {
if playing {
session.TryPauseAsync().map_err(err_of)?
} else {
session.TryPlayAsync().map_err(err_of)?
}
}
CmdAction::Next => session.TrySkipNextAsync().map_err(err_of)?,
CmdAction::Prev => session.TrySkipPreviousAsync().map_err(err_of)?,
CmdAction::Stop => session.TryStopAsync().map_err(err_of)?,
CmdAction::Seek => {
let pos = args
.as_ref()
.map(|a| a.pos_sec)
.ok_or_else(|| "seek 缺少 args.posSec".to_string())?;
let v = if pos.is_finite() && pos > 0.0 {
pos
} else {
0.0
};
// WinRT 签名是 INT64(100ns ticks),不是 TimeSpan
session
.TryChangePlaybackPositionAsync((v * TICKS_PER_SEC as f64) as i64)
.map_err(err_of)?
}
// Volume/Select/Jump 由 server 直接处理(音量走 IAudioEndpointVolume、选中走 Thing 侧覆盖、
// 选歌走前端事件链),不会路由到这里;列全仅为 match 穷尽
CmdAction::Volume | CmdAction::Select | CmdAction::Jump => {
return Err("volume/select/jump 不走 GSMTC 控制路径".into())
}
};
// 阻塞等待完成(语义 = 指令已派发,§4.2 cmd-ack)
let _ = op.get().map_err(err_of)?;
Ok(())
}
fn err_of<E: std::fmt::Display>(e: E) -> String {
format!("{e}")
}
/// 按 sessionId 找会话(`thing.self` → AUMID 匹配;否则 AUMID 全等;回退 current)。
fn find_session(manager: &GsManager, session_id: &str) -> Result<GsSession, String> {
let sessions = manager.GetSessions().map_err(err_of)?;
let n = sessions.Size().map_err(err_of)?;
for i in 0..n {
let s = sessions.GetAt(i).map_err(err_of)?;
let aumid = s
.SourceAppUserModelId()
.map(|h| h.to_string())
.unwrap_or_default();
if proto::session_key(&aumid) == session_id {
return Ok(s);
}
}
manager
.GetCurrentSession()
.map_err(|_| format!("目标会话不存在: {session_id}"))
}
+756
View File
@@ -0,0 +1,756 @@
//! 手机遥控子系统(MUSIC_REMOTE_PLAN §5.1)。
//!
//! [RemoteManager] 是本子系统的唯一状态容器(**平级 manage**,不塞进 MusicManager,
//! 见计划 §5.1):服务生命周期、配对会话、封面缓存、鉴权限速、在线设备、
//! 聚合状态(`watch<NowPlaying>`)。
//!
//! | 文件 | 职责 |
//! |---|---|
//! | [`proto`] | NowPlaying / WS 消息类型(§4)+ 单测 |
//! | [`discovery`] | UDP beacon(§3.3,含各网卡定向广播) |
//! | [`pairing`] | 配对码、设备表、token、限速(§3.4) |
//! | [`glsmtc`] | GSMTC 监视/聚合/封面 LRU/节流 + Try*Async 控制(§3.1) |
//! | [`server`] | axum HTTP+WS、鉴权、广播、心跳(§3.2 / §4.2) |
//!
//! 设置字段(`MusicSettings`,settings.json):`remote_enabled` / `remote_port` /
//! `remote_device_id` / `remote_devices`——设备**元数据**落 settings,**token** 入
//! 系统凭据管理器(键名 `music-remote-token-{id}`,§3.4-3)。
mod discovery;
mod glsmtc;
mod pairing;
mod proto;
mod server;
mod volume;
pub use pairing::RemoteDeviceMeta;
pub use proto::{NowPlaying, PROTO_VER};
/// 手机选歌 → 前端播放器的事件名(载荷 = 队列绝对下标)。
pub const REMOTE_JUMP_EVENT: &str = "music-remote-jump";
use std::collections::HashMap;
use std::hash::{Hash, Hasher};
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::thread::JoinHandle;
use serde::{Deserialize, Serialize};
use specta::Type;
use tauri::{AppHandle, Manager};
use tokio::sync::watch;
use discovery::BeaconPayload;
use glsmtc::GsmtcMonitor;
use pairing::PairingSession;
use super::MusicManager;
// ---------------------------------------------------------------------------
// 封面缓存(§6.2:内存 LRU,上限 ~20 张;/cover/:hash 由此供给)
// ---------------------------------------------------------------------------
struct CoverEntry {
bytes: Vec<u8>,
seq: u64,
}
/// 封面字节 LRU(内容哈希为键;seq 兼作 LRU 计数)。
/// P1 §7:写透到磁盘目录(`{app_data}/remote_covers`),Thing 重启后手机仍能拉到封面。
pub struct CoverStore {
map: Mutex<HashMap<String, CoverEntry>>,
seq: AtomicU64,
/// 磁盘目录(None = 仅内存;start() 时 attach)
dir: Mutex<Option<std::path::PathBuf>>,
}
impl CoverStore {
pub fn new() -> Self {
Self {
map: Mutex::new(HashMap::new()),
seq: AtomicU64::new(0),
dir: Mutex::new(None),
}
}
/// 挂载持久化目录(服务启动时调用;创建目录,失败只记日志)。
pub fn attach_dir(&self, dir: std::path::PathBuf) {
if let Err(e) = std::fs::create_dir_all(&dir) {
crate::logger::log_warn(
"music-remote",
&format!("封面持久化目录创建失败(仅内存缓存): {e}"),
);
return;
}
if let Ok(mut g) = self.dir.lock() {
*g = Some(dir);
}
}
fn dir_opt(&self) -> Option<std::path::PathBuf> {
self.dir.lock().ok().and_then(|g| g.clone())
}
/// 存入封面,返回内容哈希(同内容同哈希);超限淘汰最旧。
pub fn put(&self, bytes: &[u8]) -> Option<String> {
if bytes.is_empty() || bytes.len() > 10 * 1024 * 1024 {
return None;
}
let mut hasher = std::collections::hash_map::DefaultHasher::new();
bytes.hash(&mut hasher);
let hash = format!("{:016x}", hasher.finish());
let mut map = self.map.lock().unwrap_or_else(|e| e.into_inner());
map.insert(
hash.clone(),
CoverEntry {
bytes: bytes.to_vec(),
seq: self.seq.fetch_add(1, Ordering::Relaxed),
},
);
while map.len() > 20 {
let oldest = map
.iter()
.min_by_key(|(_, e)| e.seq)
.map(|(k, _)| k.clone());
match oldest {
Some(k) => {
map.remove(&k);
}
None => break,
}
}
drop(map);
// 写透磁盘(尽力而为;失败不影响内存路径)
if let Some(dir) = self.dir_opt() {
let path = dir.join(format!("{hash}.img"));
if std::fs::write(&path, bytes).is_ok() {
// 目录同样限 20 张:按修改时间淘汰最旧
if let Ok(rd) = std::fs::read_dir(&dir) {
let mut files: Vec<(std::time::SystemTime, std::path::PathBuf)> = rd
.flatten()
.filter_map(|e| {
let p = e.path();
if p.extension().and_then(|x| x.to_str()) != Some("img") {
return None;
}
let t = e.metadata().ok()?.modified().ok()?;
Some((t, p))
})
.collect();
if files.len() > 20 {
files.sort_by_key(|(t, _)| *t);
for (_, p) in files.iter().take(files.len() - 20) {
let _ = std::fs::remove_file(p);
}
}
}
}
}
Some(hash)
}
/// 读取(内存 → 磁盘回源;命中即刷新 LRU 序号)。
pub fn get(&self, hash: &str) -> Option<Vec<u8>> {
{
let mut map = self.map.lock().unwrap_or_else(|e| e.into_inner());
let seq = self.seq.fetch_add(1, Ordering::Relaxed);
if let Some(entry) = map.get_mut(hash) {
entry.seq = seq;
return Some(entry.bytes.clone());
}
}
// 磁盘回源(Thing 重启 / 冷缓存)
let dir = self.dir_opt()?;
let bytes = std::fs::read(dir.join(format!("{hash}.img"))).ok()?;
let mut map = self.map.lock().unwrap_or_else(|e| e.into_inner());
map.insert(
hash.to_string(),
CoverEntry {
bytes: bytes.clone(),
seq: self.seq.fetch_add(1, Ordering::Relaxed),
},
);
while map.len() > 20 {
let oldest = map
.iter()
.min_by_key(|(_, e)| e.seq)
.map(|(k, _)| k.clone());
match oldest {
Some(k) => {
map.remove(&k);
}
None => break,
}
}
Some(bytes)
}
}
impl Default for CoverStore {
fn default() -> Self {
Self::new()
}
}
// ---------------------------------------------------------------------------
// 对外状态视图(命令返回值)
// ---------------------------------------------------------------------------
/// 远程配置(§5.1 命令 `remote_get_config` / `remote_set_enabled`)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteConfig {
/// 开关(持久化)
pub enabled: bool,
/// 期望端口(0 = 默认 26124 起自动探测)
pub port: u16,
/// 服务是否在运行
pub running: bool,
/// 实际监听端口(未运行为 0)
pub running_port: u16,
/// 本机标识(beacon / NowPlaying.deviceId 同源)
pub device_id: String,
}
/// 进行中的配对信息(二维码 payload 见计划 §3.3 扫码行)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemotePairingInfo {
pub code: String,
/// `thingmusic://connect?ip=…&port=…&code=…`
pub qr_payload: String,
pub seconds_left: u64,
}
/// 设备视图(settings 元数据 + 在线态)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteDeviceView {
pub id: String,
pub name: String,
pub last_connected_ms: i64,
pub online: bool,
}
/// 服务状态(`remote_status`)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteStatus {
pub running: bool,
pub port: u16,
pub online: Vec<RemoteDeviceView>,
pub pairing: Option<RemotePairingInfo>,
}
// ---------------------------------------------------------------------------
// RemoteManager
// ---------------------------------------------------------------------------
/// 服务内部状态(start/stop 独占)。
struct Inner {
running: bool,
port: u16,
server_task: Option<tokio::task::JoinHandle<()>>,
beacon_stop: Option<Arc<AtomicBool>>,
beacon_handle: Option<JoinHandle<()>>,
pairing: Option<PairingSession>,
}
impl Default for Inner {
fn default() -> Self {
Self {
running: false,
port: 0,
server_task: None,
beacon_stop: None,
beacon_handle: None,
pairing: None,
}
}
}
pub struct RemoteManager {
/// 聚合状态(监视线程写、WS/REST 读)
pub(crate) state_tx: Arc<watch::Sender<NowPlaying>>,
/// 会话列表(P1 多会话切换;监视线程写、WS 读)
pub(crate) sessions_tx: Arc<watch::Sender<Vec<proto::SessionInfo>>>,
/// Thing 本机播放队列(前端 `remote_publish_queue` 写、WS 读)
pub(crate) queue_tx: Arc<watch::Sender<proto::QueueSnapshot>>,
/// 手机选中的目标会话覆盖(None = 跟随系统 current;WinRT 无 SetCurrentSession)
pub(crate) selected: Arc<Mutex<Option<String>>>,
/// 封面 LRU(glsmtc 写、/cover 读)
pub(crate) covers: Arc<CoverStore>,
/// hello / /pair 限速(§3.4-4)
pub(crate) auth: Arc<pairing::FailTracker>,
/// GSMTC 是否可用(false → 控制走前端事件链兜底,§5.2)
pub(crate) gsmtc_ok: Arc<AtomicBool>,
/// 服务停止信号(每个 WS 连接订阅一份)
shutdown_tx: watch::Sender<bool>,
online: Mutex<std::collections::HashSet<String>>,
monitor: Mutex<Option<GsmtcMonitor>>,
inner: Mutex<Inner>,
}
impl RemoteManager {
pub fn new() -> Self {
let (state_tx, _) = watch::channel(NowPlaying::default());
let (sessions_tx, _) = watch::channel(Vec::new());
let (queue_tx, _) = watch::channel(proto::QueueSnapshot::default());
let (shutdown_tx, _) = watch::channel(false);
Self {
state_tx: Arc::new(state_tx),
sessions_tx: Arc::new(sessions_tx),
queue_tx: Arc::new(queue_tx),
selected: Arc::new(Mutex::new(None)),
covers: Arc::new(CoverStore::new()),
auth: Arc::new(pairing::FailTracker::default()),
gsmtc_ok: Arc::new(AtomicBool::new(false)),
shutdown_tx,
online: Mutex::new(std::collections::HashSet::new()),
monitor: Mutex::new(None),
inner: Mutex::new(Inner::default()),
}
}
/// 当前聚合状态快照。
pub fn now_playing(&self) -> NowPlaying {
self.state_tx.borrow().clone()
}
/// 会话列表快照(WS 连接建立时下发)。
pub fn sessions_snapshot(&self) -> Vec<proto::SessionInfo> {
self.sessions_tx.borrow().clone()
}
/// 订阅会话列表变更(每个 WS 连接一份)。
pub fn sessions_rx(&self) -> watch::Receiver<Vec<proto::SessionInfo>> {
self.sessions_tx.subscribe()
}
/// 队列快照(WS 连接建立时下发;Thing 本机播放的队列)。
pub fn queue_snapshot(&self) -> proto::QueueSnapshot {
self.queue_tx.borrow().clone()
}
/// 订阅队列变更(每个 WS 连接一份)。
pub fn queue_rx(&self) -> watch::Receiver<proto::QueueSnapshot> {
self.queue_tx.subscribe()
}
/// 前端发布队列快照;内容没变时不推送(避免播放中反复触发 WS 帧)。
pub fn set_queue(&self, snapshot: proto::QueueSnapshot) {
let unchanged = *self.queue_tx.borrow() == snapshot;
if unchanged {
return;
}
self.queue_tx.send_replace(snapshot);
}
/// 设置目标会话覆盖;空串 = 清除(跟随系统 current)。P1 多会话切换。
pub fn set_selected(&self, session_id: &str) {
let mut g = self.selected.lock().unwrap_or_else(|e| e.into_inner());
*g = if session_id.trim().is_empty() {
None
} else {
Some(session_id.to_string())
};
}
/// cmd 后立即推一帧(§6.3 例外)。
pub fn notify_state_force(&self) {
let guard = self.monitor.lock().unwrap_or_else(|e| e.into_inner());
if let Some(m) = guard.as_ref() {
m.notify_force();
}
}
pub fn is_running(&self) -> bool {
self.inner
.lock()
.map(|g| g.running)
.unwrap_or(false)
}
pub fn running_port(&self) -> u16 {
self.inner.lock().map(|g| g.port).unwrap_or(0)
}
pub fn shutdown_rx(&self) -> watch::Receiver<bool> {
self.shutdown_tx.subscribe()
}
pub fn mark_online(&self, id: &str, on: bool) {
if let Ok(mut set) = self.online.lock() {
if on {
set.insert(id.to_string());
} else {
set.remove(id);
}
}
}
fn online_ids(&self) -> std::collections::HashSet<String> {
self.online
.lock()
.map(|s| s.clone())
.unwrap_or_default()
}
// ---------- 配对(§3.4) ----------
/// 开始配对:生成 6 位码(5 分钟有效、一次性)。服务未运行时拒绝(二维码需要端口)。
pub fn start_pairing(&self) -> Result<RemotePairingInfo, String> {
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
if !inner.running {
return Err("远程服务未启动,请先开启「手机互联」".into());
}
let session = PairingSession::generate();
// 联调辅助:配对码写入本地日志(屏幕同样可见;日志仅本机)
crate::logger::log_info(
"music-remote",
format!("配对码已生成: {}(5 分钟内有效)", session.code).as_str(),
);
let info = Self::pairing_info_of(&session, inner.port);
inner.pairing = Some(session);
Ok(info)
}
pub fn cancel_pairing(&self) {
if let Ok(mut inner) = self.inner.lock() {
inner.pairing = None;
}
}
pub fn pairing_info(&self) -> Option<RemotePairingInfo> {
let inner = self.inner.lock().ok()?;
let s = inner.pairing.as_ref()?;
if s.is_expired() {
return None;
}
Some(Self::pairing_info_of(s, inner.port))
}
fn pairing_info_of(s: &PairingSession, port: u16) -> RemotePairingInfo {
let ip = discovery::primary_ipv4()
.map(|i| i.to_string())
.unwrap_or_default();
RemotePairingInfo {
code: s.code.clone(),
qr_payload: format!("thingmusic://connect?ip={ip}&port={port}&code={}", s.code),
seconds_left: s.seconds_left(),
}
}
/// 校验并消费配对码(一次性);成功返回 Ok 并清除会话。
pub fn take_pairing_if_match(&self, code: &str) -> Result<(), String> {
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
let s = inner
.pairing
.as_ref()
.ok_or_else(|| "没有进行中的配对,请先在电脑上点「连接手机」".to_string())?;
if s.is_expired() {
inner.pairing = None;
return Err("配对码已过期(5 分钟),请重新生成".into());
}
if s.code != code.trim() {
return Err("配对码不正确".into());
}
inner.pairing = None; // 一次性
Ok(())
}
// ---------- 生命周期(§5.4) ----------
/// 启动:探测端口 → axum serve → beacon → GSMTC 监视。
pub async fn start(&self, app: &AppHandle) -> Result<(), String> {
{
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
if inner.running {
return Ok(());
}
}
// 本机标识:首次生成后持久化(beacon / NowPlaying 同源)
let music = app.state::<MusicManager>();
let mut settings = music.load_settings();
if settings.remote_device_id.trim().is_empty() {
settings.remote_device_id = pairing::random_device_id();
music.save_settings(&settings)?;
}
// 1) HTTP+WS 服务(端口探测 26124..26139)
let (port, server_task) = server::start(app.clone(), settings.remote_port).await?;
self.shutdown_tx.send_replace(false);
// 2) UDP beacon(3s;各网卡定向广播)
let payload = BeaconPayload {
service: "thing-music",
device_id: settings.remote_device_id.clone(),
name: std::env::var("COMPUTERNAME").unwrap_or_else(|_| "Thing".to_string()),
port,
proto_ver: PROTO_VER,
addrs: discovery::ipv4_broadcast_pairs()
.into_iter()
.map(|(ip, _)| ip.to_string())
.collect(),
};
let beacon_stop = Arc::new(AtomicBool::new(false));
let beacon_handle = discovery::spawn_beacon(payload, beacon_stop.clone());
// 封面持久化目录(P1 §7:重启后冷缓存可回源)
if let Ok(dir) = app.path().app_data_dir() {
self.covers.attach_dir(dir.join("remote_covers"));
}
// 3) GSMTC 监视(聚合/节流/封面/音量/会话事件;失败自动兜底,§3.1 失败策略)
let monitor = GsmtcMonitor::start(
app.clone(),
self.state_tx.clone(),
self.covers.clone(),
self.gsmtc_ok.clone(),
self.sessions_tx.clone(),
self.selected.clone(),
);
{
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
inner.running = true;
inner.port = port;
inner.server_task = Some(server_task);
inner.beacon_stop = Some(beacon_stop);
inner.beacon_handle = Some(beacon_handle);
inner.pairing = None;
}
*self.monitor.lock().unwrap_or_else(|e| e.into_inner()) = Some(monitor);
crate::logger::log_info(
"music-remote",
format!("手机互联已启动: ws://0.0.0.0:{port}(beacon :26123)").as_str(),
);
Ok(())
}
/// 停止:abort serve → 停 beacon → 停监视线程 → 清在线/配对。
pub fn stop(&self) {
let (server_task, beacon_stop, beacon_handle) = {
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
if !inner.running {
return;
}
inner.running = false;
inner.port = 0;
inner.pairing = None;
(
inner.server_task.take(),
inner.beacon_stop.take(),
inner.beacon_handle.take(),
)
};
// 停止信号:在途 WS 连接退出(§5.4 graceful;serve 直接 abort,手机端走重连)
self.shutdown_tx.send_replace(true);
if let Some(t) = server_task {
t.abort();
}
if let Some(stop) = beacon_stop {
stop.store(true, Ordering::Relaxed);
}
if let Some(h) = beacon_handle {
let _ = h.join(); // beacon 循环 ≤100ms 检查一次退出标志
}
let monitor = {
let mut guard = self.monitor.lock().unwrap_or_else(|e| e.into_inner());
guard.take()
};
if let Some(m) = monitor {
m.stop();
}
if let Ok(mut set) = self.online.lock() {
set.clear();
}
if let Ok(mut sel) = self.selected.lock() {
sel.take();
}
self.gsmtc_ok.store(false, Ordering::Relaxed);
crate::logger::log_info("music-remote", "手机互联已停止");
}
}
impl Default for RemoteManager {
fn default() -> Self {
Self::new()
}
}
// ---------------------------------------------------------------------------
// 启动钩子(setup.rs 调用)
// ---------------------------------------------------------------------------
/// 随应用启动:`remote_enabled = true` 时自动拉起服务(§5.4)。
pub fn init_on_launch(app: &AppHandle) {
let enabled = app
.try_state::<MusicManager>()
.map(|m| m.load_settings().remote_enabled)
.unwrap_or(false);
if !enabled {
return;
}
let app = app.clone();
tauri::async_runtime::spawn(async move {
let remote = app.state::<RemoteManager>();
if let Err(e) = remote.start(&app).await {
crate::logger::log_error(
"music-remote",
&format!("开机自启手机互联失败: {e}"),
);
}
});
}
// ---------------------------------------------------------------------------
// Tauri 命令(§5.1 命令表)
// ---------------------------------------------------------------------------
#[tauri::command]
#[specta::specta]
pub fn remote_get_config(app: AppHandle) -> RemoteConfig {
let music = app.state::<MusicManager>();
let s = music.load_settings();
let remote = app.state::<RemoteManager>();
RemoteConfig {
enabled: s.remote_enabled,
port: s.remote_port,
running: remote.is_running(),
running_port: remote.running_port(),
device_id: s.remote_device_id,
}
}
/// 开关(即时生效,§5.1)。
#[tauri::command]
#[specta::specta]
pub async fn remote_set_enabled(app: AppHandle, enabled: bool) -> Result<RemoteConfig, String> {
let music = app.state::<MusicManager>();
let mut s = music.load_settings();
s.remote_enabled = enabled;
music.save_settings(&s)?;
let remote = app.state::<RemoteManager>();
if enabled {
if let Err(e) = remote.start(&app).await {
// 启动失败:保留开关意图(下次启动重试),但如实上报未运行
crate::logger::log_error("music-remote", &format!("启动失败: {e}"));
return Err(e);
}
} else {
remote.stop();
}
Ok(RemoteConfig {
enabled,
port: s.remote_port,
running: remote.is_running(),
running_port: remote.running_port(),
device_id: s.remote_device_id,
})
}
#[tauri::command]
#[specta::specta]
pub fn remote_status(app: AppHandle) -> RemoteStatus {
let remote = app.state::<RemoteManager>();
let music = app.state::<MusicManager>();
let s = music.load_settings();
let online = remote.online_ids();
RemoteStatus {
running: remote.is_running(),
port: remote.running_port(),
online: s
.remote_devices
.iter()
.filter(|d| online.contains(&d.id))
.map(|d| RemoteDeviceView {
id: d.id.clone(),
name: d.name.clone(),
last_connected_ms: d.last_connected_ms,
online: true,
})
.collect(),
pairing: remote.pairing_info(),
}
}
/// 生成配对码 + 二维码 payload(前端 `qrcode` 渲染,§5.3)。
#[tauri::command]
#[specta::specta]
pub fn remote_start_pairing(app: AppHandle) -> Result<RemotePairingInfo, String> {
app.state::<RemoteManager>().start_pairing()
}
#[tauri::command]
#[specta::specta]
pub fn remote_cancel_pairing(app: AppHandle) {
app.state::<RemoteManager>().cancel_pairing();
}
/// 设备列表(元数据 + 在线态;token 永不出现在这里)。
#[tauri::command]
#[specta::specta]
pub fn remote_list_devices(app: AppHandle) -> Vec<RemoteDeviceView> {
let music = app.state::<MusicManager>();
let s = music.load_settings();
let remote = app.state::<RemoteManager>();
let online = remote.online_ids();
s.remote_devices
.into_iter()
.map(|d| RemoteDeviceView {
online: online.contains(&d.id),
id: d.id,
name: d.name,
last_connected_ms: d.last_connected_ms,
})
.collect()
}
/// 吊销设备(删表 + 删凭据;已建立的 WS 在下次重连时被拒)。
#[tauri::command]
#[specta::specta]
pub fn remote_revoke_device(app: AppHandle, id: String) -> Result<(), String> {
let music = app.state::<MusicManager>();
let mut s = music.load_settings();
s.remote_devices.retain(|d| d.id != id);
music.save_settings(&s)?;
crate::secrets::secret_delete(&pairing::token_key(&id))?;
let remote = app.state::<RemoteManager>();
remote.mark_online(&id, false);
crate::logger::log_info("music-remote", format!("已吊销设备 {id}").as_str());
Ok(())
}
/// 前端发布 Thing 本机播放队列(手机端「播放队列 / 选歌」的数据源)。
///
/// 队列活在前端 store(feiniuStore),Rust 只做快照转发;`items` 允许是完整队列
/// 的一段(见 [`proto::QueueItem::index`]),`total` 恒为完整长度。
#[tauri::command]
#[specta::specta]
pub fn remote_publish_queue(
app: AppHandle,
items: Vec<proto::QueueItem>,
index: i64,
total: i64,
) {
crate::logger::log_info(
"music-remote",
&format!(
"遥控队列更新: 本次 {} 条 / 共 {} 条,当前第 {} 条",
items.len(),
total,
index
),
);
app.state::<RemoteManager>()
.set_queue(proto::QueueSnapshot {
items,
index,
total: total.max(0),
});
}
+202
View File
@@ -0,0 +1,202 @@
//! 配对与设备表(MUSIC_REMOTE_PLAN §3.4)。
//!
//! - 配对码:6 位数字,Thing 设置页弹窗展示,**5 分钟有效期、一次性**
//! - 设备 token:32 字节随机 hex,入系统凭据管理器(`secrets.rs` 范式,键名
//! `music-remote-token-{deviceId}`);设备元数据(id/名/最后连接)落 settings
//! - 限速:hello 校验失败 3 次拉黑该 IP 60s;`/pair` 配对码校验同一限速(§3.4-4)
use std::collections::HashMap;
use std::sync::Mutex;
use std::time::{Duration, Instant};
use rand::Rng;
use serde::{Deserialize, Serialize};
use specta::Type;
/// 配对码有效期(§3.4-2)。
pub const PAIRING_TTL: Duration = Duration::from_secs(5 * 60);
/// 单 IP 失败阈值与拉黑时长(§3.4-4)。
const FAIL_LIMIT: u8 = 3;
const FAIL_BLOCK: Duration = Duration::from_secs(60);
/// 设备元数据(settings.json 持久化;**token 不在此**,见键名约定)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteDeviceMeta {
pub id: String,
pub name: String,
/// 最后一次成功连接(Unix 毫秒;0 = 从未连接)
#[serde(default)]
pub last_connected_ms: i64,
}
/// 进行中的配对会话(同一时刻至多一个)。
#[derive(Debug, Clone)]
pub struct PairingSession {
pub code: String,
pub created: Instant,
}
impl PairingSession {
pub fn generate() -> Self {
let code: u32 = rand::thread_rng().gen_range(0..1_000_000);
Self {
code: format!("{code:06}"),
created: Instant::now(),
}
}
pub fn is_expired(&self) -> bool {
self.created.elapsed() > PAIRING_TTL
}
/// 剩余秒数(前端倒计时用;已过期返回 0)。
pub fn seconds_left(&self) -> u64 {
PAIRING_TTL
.saturating_sub(self.created.elapsed())
.as_secs()
}
}
/// 凭据键名:与 `secrets.rs` 的服务名 `Thing` 组合成完整凭据项。
pub fn token_key(device_id: &str) -> String {
format!("music-remote-token-{device_id}")
}
/// 生成 32 字节随机 hex token(§3.4-3)。
pub fn random_token() -> String {
let mut buf = [0u8; 32];
rand::thread_rng().fill(&mut buf);
hex_encode(&buf)
}
/// 生成 16 字节随机 hex 设备 id。
pub fn random_device_id() -> String {
let mut buf = [0u8; 16];
rand::thread_rng().fill(&mut buf);
hex_encode(&buf)
}
fn hex_encode(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
/// 按 token 找设备:遍历 settings 中的设备 id,逐个读凭据库比对。
/// 设备数很少(个位数),O(n) 读可接受;token 不落 settings(§3.4-3)。
pub fn device_by_token(
devices: &[RemoteDeviceMeta],
token: &str,
) -> Option<RemoteDeviceMeta> {
if token.is_empty() {
return None;
}
for d in devices {
let stored = crate::secrets::read_or_empty(&token_key(&d.id));
if !stored.is_empty() && stored == token {
return Some(d.clone());
}
}
None
}
/// 单 IP 失败计数 / 拉黑表(hello 与 /pair 共用)。
#[derive(Default)]
pub struct FailTracker {
inner: Mutex<HashMap<String, FailState>>,
}
#[derive(Clone, Copy)]
struct FailState {
fails: u8,
last: Instant,
blocked_until: Option<Instant>,
}
impl FailTracker {
/// 该 IP 当前是否允许尝试(在拉黑窗口内 → false)。
pub fn allowed(&self, ip: &str) -> bool {
let map = self.inner.lock().unwrap_or_else(|e| e.into_inner());
match map.get(ip) {
Some(s) => match s.blocked_until {
Some(t) => Instant::now() >= t,
None => true,
},
None => true,
}
}
/// 记一次失败:累计 3 次拉黑 60s;60s 后的失败重新计数。
pub fn fail(&self, ip: &str) {
let mut map = self.inner.lock().unwrap_or_else(|e| e.into_inner());
let now = Instant::now();
let s = map.entry(ip.to_string()).or_insert(FailState {
fails: 0,
last: now,
blocked_until: None,
});
if let Some(t) = s.blocked_until {
if now >= t {
s.fails = 0;
s.blocked_until = None;
}
}
if now.duration_since(s.last) > FAIL_BLOCK {
s.fails = 0;
}
s.last = now;
s.fails += 1;
if s.fails >= FAIL_LIMIT {
s.blocked_until = Some(now + FAIL_BLOCK);
crate::logger::log_warn(
"music-remote",
&format!("IP {ip} 鉴权失败 {FAIL_LIMIT} 次,拉黑 60s"),
);
}
}
/// 成功后清零。
pub fn ok(&self, ip: &str) {
self.inner
.lock()
.unwrap_or_else(|e| e.into_inner())
.remove(ip);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pairing_code_format_and_ttl() {
let p = PairingSession::generate();
assert_eq!(p.code.len(), 6);
assert!(p.code.chars().all(|c| c.is_ascii_digit()));
assert!(!p.is_expired());
assert!(p.seconds_left() <= 300);
}
#[test]
fn fail_tracker_blocks_after_three() {
let t = FailTracker::default();
assert!(t.allowed("1.2.3.4"));
t.fail("1.2.3.4");
t.fail("1.2.3.4");
assert!(t.allowed("1.2.3.4"));
t.fail("1.2.3.4");
assert!(!t.allowed("1.2.3.4"));
// 其他 IP 不受影响
assert!(t.allowed("5.6.7.8"));
t.ok("1.2.3.4");
assert!(t.allowed("1.2.3.4"));
}
#[test]
fn token_shape() {
let t = random_token();
assert_eq!(t.len(), 64);
assert!(t.chars().all(|c| c.is_ascii_hexdigit()));
assert_eq!(random_device_id().len(), 32);
assert_eq!(token_key("abc"), "music-remote-token-abc");
}
}
+523
View File
@@ -0,0 +1,523 @@
//! 遥控协议类型(MUSIC_REMOTE_PLAN §4)。
//!
//! WS 线格式:JSON,`type` 字段判别,字段一律 camelCase。
//! 这些类型**不进 specta bindings**——协议对端是手机(LFMusic 在 `remote-proto.ts`
//! 手写一份镜像类型),Thing 前端不直接消费 WS;此处只负责 serde 序列化与单测。
//! 双端字段一旦改动,必须同步对端文档 §4 与 LFMusic 的镜像类型(计划"复制+注释互指")。
use serde::{Deserialize, Serialize};
/// 协议版本:不匹配时 `welcome` 带最新版本号,手机端提示升级(§4.2)。
pub const PROTO_VER: u32 = 1;
/// Thing 自身会话的 sessionId(§4.1)。
pub const THING_SELF_SESSION: &str = "thing.self";
/// Thing 自身的 AUMID(与 lib.rs `set_app_user_model_id` 一致)。
pub const THING_AUMID: &str = "thing.lfeng.me";
/// 控制能力位:手机端据此置灰按钮(§4.1)。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanControl {
pub play: bool,
pub pause: bool,
pub next: bool,
pub prev: bool,
pub seek: bool,
}
/// 播放状态(§4.1 `status`)。
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum PlayStatus {
Playing,
Paused,
Stopped,
}
impl Default for PlayStatus {
fn default() -> Self {
Self::Stopped
}
}
/// 当前播放状态快照:WS `state` 消息的载荷(§4.1)。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NowPlaying {
/// 会话 key:Thing 自身 = [`THING_SELF_SESSION`],其余为 SourceAppUserModelId
pub session_id: String,
/// 来源应用显示名(AUMID 简化,友好名映射 P1)
pub source_app: String,
/// 是否 Thing 自身播放(封面/元数据兜底、seek 直通判定)
pub is_thing: bool,
pub title: String,
pub artist: String,
pub album: String,
/// 封面缓存键;封面从 `GET /cover/:hash` 拉取
pub cover_hash: Option<String>,
pub status: PlayStatus,
pub duration_sec: f64,
/// 推送时刻的播放位置(秒)
pub position_sec: f64,
/// 电脑时钟毫秒(源自 TimelineProperties.LastUpdatedTime,§6.4)。
/// **仅供校准**:手机端 elapsed 一律以本地收包时刻起算(§6.10)
pub position_updated_at_ms: i64,
pub playback_rate: f64,
pub can_control: CanControl,
/// 系统主音量(0.0~1.0;None = 音频端点不可用,手机端隐藏音量条)。P1 §7
pub volume: Option<f64>,
/// 系统主音量静音位
pub muted: bool,
/// 电脑标识(beacon 同源,多电脑预留)
pub device_id: String,
}
impl Default for NowPlaying {
fn default() -> Self {
Self {
session_id: String::new(),
source_app: String::new(),
is_thing: false,
title: String::new(),
artist: String::new(),
album: String::new(),
cover_hash: None,
status: PlayStatus::Stopped,
duration_sec: 0.0,
position_sec: 0.0,
position_updated_at_ms: 0,
playback_rate: 1.0,
can_control: CanControl {
play: false,
pause: false,
next: false,
prev: false,
seek: false,
},
volume: None,
muted: false,
device_id: String::new(),
}
}
}
impl NowPlaying {
/// 「无播放」快照(§5.2 两者都无:status = stopped,手机显示"电脑未在播放")。
pub fn stopped(device_id: &str) -> Self {
Self {
device_id: device_id.to_string(),
..Default::default()
}
}
}
/// 会话列表条目(P1 §7 多会话切换:手机端可选"控制哪个应用")。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SessionInfo {
pub session_id: String,
pub source_app: String,
pub title: String,
pub artist: String,
pub status: PlayStatus,
pub is_thing: bool,
/// 是否当前展示/控制目标(Thing 侧选中覆盖;无覆盖时为系统 current)
pub is_current: bool,
}
/// 播放队列条目(Thing 专属:本机播放器的队列,手机端可选歌)。
///
/// `index` 是**在完整队列里的绝对下标**——下发时允许只带当前附近的一段
/// (前端最多推 500 条,见 feiniuStore),手机端跳歌直接把 index 回传。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, specta::Type)]
#[serde(rename_all = "camelCase")]
pub struct QueueItem {
pub index: i64,
pub title: String,
pub artist: String,
pub duration_sec: f64,
}
/// 播放队列快照(WS `queue` 消息;`total` 是完整队列长度,可能大于 `items` 条数)。
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct QueueSnapshot {
pub items: Vec<QueueItem>,
/// 当前播放条目在完整队列中的下标(-1 = 未在队列中播放)
pub index: i64,
pub total: i64,
}
/// 会话 key(§4.1 / §6.5):Thing 自身固定为 `thing.self`,其余直接用 AUMID。
pub fn session_key(aumid: &str) -> String {
if is_thing_aumid(aumid) {
THING_SELF_SESSION.to_string()
} else {
aumid.to_string()
}
}
/// AUMID 是否为 Thing 自身。
pub fn is_thing_aumid(aumid: &str) -> bool {
aumid.eq_ignore_ascii_case(THING_AUMID)
}
/// 来源应用显示名(P0:取 AUMID 简化段;注册表友好名映射在 P1 §6.7)。
///
/// AUMID 形态:`PackageFamilyName!App` | `C:\Path\App.exe -Args` | `ProgId.App`。
pub fn source_display(aumid: &str) -> String {
// Thing 自身 AUMID 是标识符而非程序名,直接给友好名
if is_thing_aumid(aumid) {
return "Thing".to_string();
}
let core = aumid
.split(['!', '\\'])
.next_back()
.unwrap_or(aumid)
.split(' ')
.next()
.unwrap_or(aumid);
core.trim().trim_end_matches(".exe").to_string()
}
/// 控制动作(§4.2 `cmd.action`;Volume/Select 为 P1 扩展)。
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum CmdAction {
Play,
Pause,
Toggle,
Next,
Prev,
Stop,
Seek,
/// 系统主音量:args.level(0.0~1.0;>0 时顺带解除静音)
Volume,
/// 切换展示/控制的会话:args.sessionId(空串 = 取消覆盖,跟随系统 current)
Select,
/// 跳到队列指定条目(Thing 专属):args.index = 队列绝对下标
Jump,
}
/// `cmd` 的可选参数(serde default:缺省字段按0/空处理,各动作只读自己需要的)。
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CmdArgs {
/// seek 目标位置(秒)
#[serde(default)]
pub pos_sec: f64,
/// volume 目标音量(0.0~1.0)
#[serde(default)]
pub level: f64,
/// select 目标会话(空串 = 跟随系统)
#[serde(default)]
pub session_id: String,
/// jump 目标下标(队列绝对下标;-1 = 未提供)
#[serde(default = "jump_index_default")]
pub index: i64,
}
fn jump_index_default() -> i64 {
-1
}
/// WS 消息(§4.2)。`type` 字段判别;`state` 展平 [`NowPlaying`] 字段。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "type",
rename_all = "camelCase",
rename_all_fields = "camelCase"
)]
pub enum WsMessage {
/// c→s:连接后首条,失败即断开
Hello {
token: String,
device_name: String,
proto_ver: u32,
},
/// s→c:鉴权通过
Welcome {
device_id: String,
device_name: String,
proto_ver: u32,
},
/// s→c:全量状态(连接后、变更、cmd 触发立即帧)
State {
#[serde(flatten)]
now: NowPlaying,
},
/// s→c:会话列表(P1;连接后、列表或当前目标变化时推送)
Sessions {
sessions: Vec<SessionInfo>,
},
/// s→c:Thing 本机播放队列(连接后、队列或当前曲目变化时推送)
Queue {
items: Vec<QueueItem>,
index: i64,
total: i64,
},
/// c→s:用户操作
Cmd {
id: String,
action: CmdAction,
#[serde(default, skip_serializing_if = "Option::is_none")]
args: Option<CmdArgs>,
},
/// s→c:回执(语义 = 指令已被接受/派发,状态以随后的 `state` 为准)
///
/// 显式 rename:外层 `rename_all = "camelCase"` 会把变体名也转成 `cmdAck`,
/// 而 §4.2 线格式与手机端都写的是 `cmd-ack` —— 不锁死就会让手机端把
/// **每一条错误回执都静默丢掉**(见 `cmd_ack_wire_type` 单测)。
#[serde(rename = "cmd-ack")]
CmdAck {
id: String,
ok: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
error: Option<String>,
},
/// c→s / s→c:30s 心跳
Ping { ts: i64 },
Pong { ts: i64 },
}
/// WinRT `DateTime.UniversalTime`(100ns since **1601-01-01 UTC**,即 FILETIME 纪元)→ Unix 毫秒。
/// `positionUpdatedAtMs` 的换算基准(§6.4:源是 `LastUpdatedTime`)。
///
/// 纪元是实测确认的(不是 .NET 的 0001-01-01):`gsmtc_dump` 里 QQMusic/Thing 会话的
/// `LastUpdatedTime` ≈1.343e17 ticks,按 1601 纪元换算分别落在"47 分钟前 / 4.5 秒前",
/// 与实际播放/暂停时刻吻合;按 0001 纪元则落在公元 426 年——Windows.Media.Control 的
/// `TimelineProperties.LastUpdatedTime` 走 FILETIME,用错纪元会得到巨额负数,
/// 手机端 `positionUpdatedAtMs > 0` 判定恒假 → 时钟偏差冻结(§6.10)形同虚设。
pub fn winrt_ticks_to_unix_ms(ticks: i64) -> i64 {
// 1601-01-01 → 1970-01-01:621355968 天 × 86400s × 1e7 ticks ÷ 1e4
ticks / 10_000 - 11_644_473_600_000
}
#[cfg(test)]
mod tests {
use super::*;
/// 序列化往返:保证双端 JSON 形状与字段名(camelCase)稳定(P0 单测项)。
#[test]
fn now_playing_roundtrip() {
let np = NowPlaying {
session_id: THING_SELF_SESSION.to_string(),
source_app: "网易云播放器".to_string(),
is_thing: false,
title: "园游会".to_string(),
artist: "周杰伦".to_string(),
album: "七里香".to_string(),
cover_hash: Some("ab12".to_string()),
status: PlayStatus::Playing,
duration_sec: 255.5,
position_sec: 12.25,
position_updated_at_ms: 1_790_000_000_000,
playback_rate: 1.0,
can_control: CanControl {
play: true,
pause: true,
next: true,
prev: true,
seek: true,
},
volume: Some(0.66),
muted: false,
device_id: "dev1".to_string(),
};
let msg = WsMessage::State { now: np.clone() };
let json = serde_json::to_string(&msg).unwrap();
// 字段名锁定(camelCase;双端漂移防线)
assert!(json.contains("\"type\":\"state\""));
assert!(json.contains("\"sessionId\""));
assert!(json.contains("\"coverHash\""));
assert!(json.contains("\"positionUpdatedAtMs\""));
assert!(json.contains("\"canControl\""));
assert!(json.contains("\"isThing\""));
assert!(json.contains("\"status\":\"playing\""));
assert!(json.contains("\"volume\":0.66"));
assert!(json.contains("\"muted\":false"));
let back: WsMessage = serde_json::from_str(&json).unwrap();
assert_eq!(back, msg);
}
/// P1:sessions 消息与 select/volume 动作的线格式锁定。
#[test]
fn sessions_and_p1_actions_roundtrip() {
let msg = WsMessage::Sessions {
sessions: vec![SessionInfo {
session_id: THING_SELF_SESSION.to_string(),
source_app: "Thing".into(),
title: "园游会".into(),
artist: "周杰伦".into(),
status: PlayStatus::Playing,
is_thing: true,
is_current: true,
}],
};
let json = serde_json::to_string(&msg).unwrap();
assert!(json.contains("\"type\":\"sessions\""));
assert!(json.contains("\"isCurrent\":true"));
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), msg);
let volume = WsMessage::Cmd {
id: "v1".into(),
action: CmdAction::Volume,
args: Some(CmdArgs {
level: 0.5,
..Default::default()
}),
};
let json = serde_json::to_string(&volume).unwrap();
assert!(json.contains("\"action\":\"volume\""));
assert!(json.contains("\"level\":0.5"));
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), volume);
let select = WsMessage::Cmd {
id: "s1".into(),
action: CmdAction::Select,
args: Some(CmdArgs {
session_id: THING_SELF_SESSION.into(),
..Default::default()
}),
};
let json = serde_json::to_string(&select).unwrap();
assert!(json.contains("\"action\":\"select\""));
assert!(json.contains("\"sessionId\":\"thing.self\""));
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), select);
// 队列下发 + 选歌(Thing 专属能力)的线格式锁定
let queue = WsMessage::Queue {
items: vec![QueueItem {
index: 7,
title: "园游会".into(),
artist: "周杰伦".into(),
duration_sec: 255.5,
}],
index: 7,
total: 120,
};
let json = serde_json::to_string(&queue).unwrap();
assert!(json.contains("\"type\":\"queue\""));
assert!(json.contains("\"items\""));
assert!(json.contains("\"durationSec\":255.5"));
assert!(json.contains("\"total\":120"));
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), queue);
let jump = WsMessage::Cmd {
id: "j1".into(),
action: CmdAction::Jump,
args: Some(CmdArgs {
index: 7,
..Default::default()
}),
};
let json = serde_json::to_string(&jump).unwrap();
assert!(json.contains("\"action\":\"jump\""));
assert!(json.contains("\"index\":7"));
// 缺 index 的旧客户端 → 反序列化为 -1(服务端据此拒绝)
assert_eq!(serde_json::from_str::<CmdArgs>(r#"{}"#).unwrap().index, -1);
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), jump);
}
#[test]
fn hello_ack_cmd_roundtrip() {
for msg in [
WsMessage::Hello {
token: "t".repeat(64),
device_name: "Pixel".to_string(),
proto_ver: PROTO_VER,
},
WsMessage::Welcome {
device_id: "d".to_string(),
device_name: "Thing".to_string(),
proto_ver: PROTO_VER,
},
WsMessage::Cmd {
id: "1".to_string(),
action: CmdAction::Seek,
args: Some(CmdArgs {
pos_sec: 42.0,
..Default::default()
}),
},
WsMessage::Cmd {
id: "2".to_string(),
action: CmdAction::Toggle,
args: None,
},
WsMessage::CmdAck {
id: "1".to_string(),
ok: false,
error: Some("frontend-unavailable".to_string()),
},
WsMessage::Ping { ts: 1 },
WsMessage::Pong { ts: 1 },
] {
let json = serde_json::to_string(&msg).unwrap();
let back: WsMessage = serde_json::from_str(&json).unwrap();
assert_eq!(back, msg, "{json}");
}
// action 枚举的线格式锁定
let json = serde_json::to_string(&WsMessage::Cmd {
id: "3".into(),
action: CmdAction::Next,
args: None,
})
.unwrap();
assert!(json.contains("\"action\":\"next\""));
// 无 args 时不出现该键
assert!(!json.contains("args"));
}
/// 回执的 `type` 必须是 `cmd-ack`(§4.2 表格与手机端 switch 的字面量)。
/// 外层 `rename_all = "camelCase"` 连变体名一起转,会产出 `cmdAck`——
/// 漏掉显式 rename 时手机端匹配不上,**每一条错误回执都被静默丢掉**
/// (表现为:指令被拒绝却无提示、手机端保持窗口只能等超时才回退)。
#[test]
fn cmd_ack_wire_type() {
let ack = WsMessage::CmdAck {
id: "1".into(),
ok: false,
error: Some("boom".into()),
};
let json = serde_json::to_string(&ack).unwrap();
assert!(json.contains("\"type\":\"cmd-ack\""), "{json}");
assert!(!json.contains("cmdAck"), "{json}");
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), ack);
}
#[test]
fn session_key_and_display() {
assert_eq!(session_key(THING_AUMID), THING_SELF_SESSION);
assert_eq!(session_key("cloudmusic.exe"), "cloudmusic.exe");
assert!(is_thing_aumid("Thing.Lfeng.ME"));
assert_eq!(
source_display(r"KuGou\kugou.exe"),
"kugou".to_string()
);
assert_eq!(source_display("Museify_zzdnekvpz2s88!Spotify"), "Spotify");
// Thing 自身 AUMID → 友好名(手机端不应看到 thing.lfeng.me)
assert_eq!(source_display(THING_AUMID), "Thing");
}
/// WinRT DateTime(100ns since **1601-01-01**,FILETIME 纪元)→ Unix 毫秒(§6.4 换算基准)。
#[test]
fn winrt_datetime_to_unix_ms() {
// 1970-01-01 的 FILETIME ticks:621355968 天 × 86400s × 1e7
assert_eq!(winrt_ticks_to_unix_ms(116_444_736_000_000_000), 0);
// 2026-09-25 00:00:00 UTC ≈ 1_790_332_800_000 ms
let unix_ms = 1_790_332_800_000i64;
let ticks = (unix_ms + 11_644_473_600_000) * 10_000;
assert_eq!(winrt_ticks_to_unix_ms(ticks), unix_ms);
// 实测样本(gsmtc_dump 抓到的 Thing 自身会话 LastUpdatedTime):
// 对应 1790499938437 ms,即抓取时刻 4.5 秒前——按 0001 纪元算会落到公元 426 年
assert_eq!(
winrt_ticks_to_unix_ms(134_349_735_384_378_473),
1_790_499_938_437
);
// 0 = 来源从未上报过时间轴(bilibili PC 实测)→ 换算必为负,
// 调用方(glsmtc)据此钳成 0 作「无进度基准」哨兵
assert!(winrt_ticks_to_unix_ms(0) < 0);
}
}
+610
View File
@@ -0,0 +1,610 @@
//! 局域网服务:axum HTTP + WebSocket(MUSIC_REMOTE_PLAN §3.2 / §4.2 / §5.1 `server.rs`)。
//!
//! | 端点 | 用途 |
//! |---|---|
//! | `/ws` | 主通道:hello 鉴权、state 推送、cmd 控制、心跳 |
//! | `/api/state` | REST 快照兜底(Bearer) |
//! | `/cover/:hash` | 封面字节流(`<img>` 带不了 header → `?t=token`) |
//! | `/pair` | 配对换 token(6 位码 + 限速) |
//!
//! 全部监听 `0.0.0.0`;实际端口在启动时按 26124→26139 探测(§3.2),
//! 由 RemoteManager 写回 beacon 与配对二维码。
use std::net::SocketAddr;
use std::time::{Duration, Instant};
use axum::extract::ws::{Message as AxumWs, WebSocket, WebSocketUpgrade};
use axum::extract::{ConnectInfo, Path, Query, State};
use axum::http::{header, HeaderMap, StatusCode};
use axum::response::{IntoResponse, Response};
use axum::routing::{get, post};
use axum::{Json, Router};
use futures_util::{SinkExt, StreamExt};
use serde::{Deserialize, Serialize};
use tauri::{AppHandle, Emitter, Manager};
use super::glsmtc;
use super::pairing::{self, RemoteDeviceMeta};
use super::proto::{
CmdAction, CmdArgs, NowPlaying, WsMessage, PROTO_VER,
};
use super::RemoteManager;
use crate::music::{AudioEngine, MusicManager};
use crate::music::smtc::SMTC_BUTTON_EVENT;
/// WS 首条消息(hello)超时(§4.2 连接后首条)。
const HELLO_TIMEOUT: Duration = Duration::from_secs(10);
/// 心跳周期(§4.2 30s 双向判活)。
const HEARTBEAT: Duration = Duration::from_secs(30);
/// 超过该时长无任何入站消息 → 判死断开(§5.4 心跳判活)。
const IDLE_TIMEOUT: Duration = Duration::from_secs(90);
#[derive(Clone)]
pub struct AppState {
pub app: AppHandle,
}
/// 构建路由(§3.2 四个端点)。
pub fn router(app: AppHandle) -> Router {
Router::new()
.route("/ws", get(ws_upgrade))
.route("/api/state", get(api_state))
.route("/cover/:hash", get(cover))
.route("/pair", post(pair))
.with_state(AppState { app })
}
/// 启动服务:preferred=0 时从 26124 起,被占 +1 直至 26139(§3.2)。
/// 成功返回(实际端口, serve 任务句柄);stop 时由 RemoteManager abort。
pub async fn start(
app: AppHandle,
preferred: u16,
) -> Result<(u16, tokio::task::JoinHandle<()>), String> {
let from = if preferred == 0 { 26124 } else { preferred };
let to = from.clamp(26124, 26139).min(26139);
let mut bound: Option<(u16, tokio::net::TcpListener)> = None;
for port in from..=to {
match tokio::net::TcpListener::bind(("0.0.0.0", port)).await {
Ok(l) => {
bound = Some((port, l));
break;
}
Err(e) => {
crate::logger::log_warn(
"music-remote",
&format!("端口 {port} 绑定失败({e}),尝试下一个"),
);
}
}
}
let (port, listener) = bound.ok_or_else(|| {
format!("远程服务端口 {from}-{to} 全部不可用(被占用或无权限)")
})?;
let router = router(app);
let handle = tokio::task::spawn(async move {
let svc = router.into_make_service_with_connect_info::<SocketAddr>();
if let Err(e) = axum::serve(listener, svc).await {
// abort 时 axum::serve 返回的错误走这里降级为日志(abort 本身另算)
crate::logger::log_warn("music-remote", &format!("axum 服务结束: {e}"));
}
});
Ok((port, handle))
}
// ---------------------------------------------------------------------------
// 鉴权
// ---------------------------------------------------------------------------
fn bearer_token(headers: &HeaderMap) -> Option<String> {
headers
.get(header::AUTHORIZATION)?
.to_str()
.ok()?
.strip_prefix("Bearer ")
.map(|s| s.to_string())
}
/// 校验设备 token → 设备信息;失败为 None(不做限速——限速由调用方按场景加)。
fn validate_token(app: &AppHandle, token: &str) -> Option<RemoteDeviceMeta> {
let music = app.state::<MusicManager>();
let settings = music.load_settings();
pairing::device_by_token(&settings.remote_devices, token)
}
fn require_bearer(app: &AppHandle, headers: &HeaderMap) -> Result<RemoteDeviceMeta, StatusCode> {
let token = bearer_token(headers).ok_or(StatusCode::UNAUTHORIZED)?;
validate_token(app, &token).ok_or(StatusCode::UNAUTHORIZED)
}
// ---------------------------------------------------------------------------
// REST:/api/state、/cover/:hash
// ---------------------------------------------------------------------------
async fn api_state(
State(st): State<AppState>,
headers: HeaderMap,
) -> Result<Json<NowPlaying>, StatusCode> {
require_bearer(&st.app, &headers)?;
let remote = st.app.state::<RemoteManager>();
Ok(Json(remote.now_playing()))
}
#[derive(Deserialize)]
struct CoverQuery {
/// 鉴权 token(`<img>` 无法带 Authorization header,§3.2)
#[serde(rename = "t")]
t: Option<String>,
}
async fn cover(
State(st): State<AppState>,
Path(hash): Path<String>,
Query(q): Query<CoverQuery>,
headers: HeaderMap,
) -> Result<Response, StatusCode> {
let token = q.t.or_else(|| bearer_token(&headers));
let token = token.ok_or(StatusCode::UNAUTHORIZED)?;
validate_token(&st.app, &token).ok_or(StatusCode::UNAUTHORIZED)?;
let remote = st.app.state::<RemoteManager>();
let bytes = remote.covers.get(&hash).ok_or(StatusCode::NOT_FOUND)?;
// 访问日志不打印 query(§3.2):logger 不记录请求行,天然满足;此处只管响应
let ct = sniff_content_type(&bytes);
Ok(([(header::CONTENT_TYPE, ct)], bytes).into_response())
}
fn sniff_content_type(bytes: &[u8]) -> &'static str {
if bytes.starts_with(&[0x89, b'P', b'N', b'G']) {
"image/png"
} else if bytes.starts_with(&[0xFF, 0xD8]) {
"image/jpeg"
} else if bytes.len() > 12 && &bytes[0..4] == b"RIFF" && &bytes[8..12] == b"WEBP" {
"image/webp"
} else {
"application/octet-stream"
}
}
// ---------------------------------------------------------------------------
// POST /pair(§3.4)
// ---------------------------------------------------------------------------
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct PairRequest {
pairing_code: String,
device_name: String,
}
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct PairResponse {
token: String,
device_id: String,
}
#[derive(Serialize)]
struct HttpError {
error: String,
}
async fn pair(
State(st): State<AppState>,
ConnectInfo(addr): ConnectInfo<SocketAddr>,
Json(req): Json<PairRequest>,
) -> Result<(StatusCode, Json<PairResponse>), (StatusCode, Json<HttpError>)> {
let ip = addr.ip().to_string();
let remote = st.app.state::<RemoteManager>();
let denied = |msg: &str| {
(
StatusCode::TOO_MANY_REQUESTS,
Json(HttpError {
error: msg.to_string(),
}),
)
};
if !remote.auth.allowed(&ip) {
return Err(denied("尝试过于频繁,60s 后再试"));
}
// 配对码校验:存在 + 未过期 + 匹配(一次性:成功即清除)
match remote.take_pairing_if_match(&req.pairing_code) {
Ok(()) => remote.auth.ok(&ip),
Err(e) => {
remote.auth.fail(&ip);
return Err((
StatusCode::FORBIDDEN,
Json(HttpError { error: e }),
));
}
}
let device_id = pairing::random_device_id();
let token = pairing::random_token();
// token 先入凭据库,成功才落设备表(§3.4-3 顺序)
let key = pairing::token_key(&device_id);
if let Err(e) = crate::secrets::secret_write(&key, &token) {
crate::logger::log_error("music-remote", &format!("设备 token 写入凭据库失败: {e}"));
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
Json(HttpError {
error: "保存设备凭据失败".to_string(),
}),
));
}
let name = if req.device_name.trim().is_empty() {
format!("手机设备 {}", &device_id[..6])
} else {
req.device_name.trim().to_string()
};
let music = st.app.state::<MusicManager>();
let mut settings = music.load_settings();
settings.remote_devices.push(RemoteDeviceMeta {
id: device_id.clone(),
name,
last_connected_ms: 0,
});
if let Err(e) = music.save_settings(&settings) {
crate::logger::log_error("music-remote", &format!("设备表落盘失败: {e}"));
}
crate::logger::log_info(
"music-remote",
format!("设备配对成功: {device_id}({ip})").as_str(),
);
Ok((
StatusCode::OK,
Json(PairResponse { token, device_id }),
))
}
// ---------------------------------------------------------------------------
// WebSocket(§4.2)
// ---------------------------------------------------------------------------
async fn ws_upgrade(
State(st): State<AppState>,
ConnectInfo(addr): ConnectInfo<SocketAddr>,
upgrade: WebSocketUpgrade,
) -> Response {
// 升级阶段不鉴权:手机 WebSocket 无法带 Authorization header,
// token 在升级后的首条 `hello` 消息里(§4.2)
upgrade
.on_upgrade(move |socket| handle_socket(st.app, addr, socket))
.into_response()
}
async fn handle_socket(app: AppHandle, addr: SocketAddr, socket: WebSocket) {
let ip = addr.ip().to_string();
let (mut sink, mut stream) = socket.split();
// 1) 首条必须是 hello(10s 超时)
let hello = match tokio::time::timeout(HELLO_TIMEOUT, stream.next()).await {
Ok(Some(Ok(AxumWs::Text(t)))) => match serde_json::from_str::<WsMessage>(&t) {
Ok(WsMessage::Hello {
token,
device_name,
..
}) => (token, device_name),
_ => {
let _ = sink.send(AxumWs::Close(None)).await;
return;
}
},
_ => {
let _ = sink.send(AxumWs::Close(None)).await;
return;
}
};
let (token, device_name) = hello;
let remote = app.state::<RemoteManager>();
if !remote.auth.allowed(&ip) {
let _ = sink.send(AxumWs::Close(None)).await;
return;
}
let device = match validate_token(&app, &token) {
Some(d) => {
remote.auth.ok(&ip);
d
}
None => {
remote.auth.fail(&ip);
crate::logger::log_warn("music-remote", &format!("hello 鉴权失败({ip})"));
let _ = sink.send(AxumWs::Close(None)).await;
return;
}
};
// 2) 上线登记 + 最后连接时间
remote.mark_online(&device.id, true);
touch_last_connected(&app, &device.id);
// 3) welcome + 首帧 state + 会话列表(§5.1 welcome → 全量;sessions 为 P1)
let mut state_rx = remote.state_tx.subscribe();
let mut sessions_rx = remote.sessions_rx();
let mut queue_rx = remote.queue_rx();
let mut rx = remote.shutdown_rx();
let device_id = device.id.clone();
let send_json = |msg: &WsMessage| -> String { serde_json::to_string(msg).unwrap_or_default() };
if sink
.send(AxumWs::Text(send_json(&WsMessage::Welcome {
device_id: device_id.clone(),
device_name: device_name.clone(),
proto_ver: PROTO_VER,
})))
.await
.is_err()
{
remote.mark_online(&device_id, false);
return;
}
{
let now = remote.now_playing();
let _ = sink
.send(AxumWs::Text(send_json(&WsMessage::State { now })))
.await;
}
{
let sessions = remote.sessions_snapshot();
let _ = sink
.send(AxumWs::Text(send_json(&WsMessage::Sessions { sessions })))
.await;
}
{
let q = remote.queue_snapshot();
let _ = sink.send(AxumWs::Text(send_json(&queue_msg(&q)))).await;
}
crate::logger::log_info(
"music-remote",
format!("WS 已连接: {device_name}({ip})").as_str(),
);
// 4) 主循环:入站消息 / 状态变更推送 / 心跳
let mut last_in = Instant::now();
let mut beat = tokio::time::interval(HEARTBEAT);
beat.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
loop {
tokio::select! {
// 心跳与判活(§4.2 / §5.4)
_ = beat.tick() => {
if last_in.elapsed() > IDLE_TIMEOUT {
crate::logger::log_warn("music-remote", &format!("心跳超时,断开 {device_name}({ip})"));
break;
}
if sink.send(AxumWs::Text(send_json(&WsMessage::Ping { ts: now_ms() }))).await.is_err() {
break;
}
}
// 服务停止
_ = rx.changed() => {
if *rx.borrow() { break; }
}
// 状态推送(watch:节流/Force 均已在监视线程收敛,§6.3)
changed = state_rx.changed() => {
if changed.is_err() { break; }
let now = state_rx.borrow_and_update().clone();
if sink.send(AxumWs::Text(send_json(&WsMessage::State { now }))).await.is_err() {
break;
}
}
// 会话列表变更(P1 多会话切换)
changed = sessions_rx.changed() => {
if changed.is_err() { break; }
let sessions = sessions_rx.borrow_and_update().clone();
if sink.send(AxumWs::Text(send_json(&WsMessage::Sessions { sessions }))).await.is_err() {
break;
}
}
// Thing 本机队列变更(前端发布:切歌 / 增删队列)
changed = queue_rx.changed() => {
if changed.is_err() { break; }
let snap = queue_rx.borrow_and_update().clone();
if sink.send(AxumWs::Text(send_json(&queue_msg(&snap)))).await.is_err() {
break;
}
}
incoming = stream.next() => {
match incoming {
Some(Ok(AxumWs::Text(t))) => {
last_in = Instant::now();
match serde_json::from_str::<WsMessage>(&t) {
Ok(WsMessage::Cmd { id, action, args }) => {
let res = dispatch_cmd(&app, action, args).await;
let ack = WsMessage::CmdAck {
id,
ok: res.is_ok(),
error: res.err(),
};
if sink.send(AxumWs::Text(send_json(&ack))).await.is_err() {
break;
}
// cmd 触发的 state 立即帧由监视线程 Force 产生(§6.3 例外)
}
Ok(WsMessage::Ping { ts }) => {
if sink.send(AxumWs::Text(send_json(&WsMessage::Pong { ts }))).await.is_err() {
break;
}
}
Ok(WsMessage::Pong { .. }) => {}
// 重复 hello / 非法消息:忽略(连接保持,状态以服务端为准)
_ => {}
}
}
Some(Ok(AxumWs::Ping(p))) => {
last_in = Instant::now();
if sink.send(AxumWs::Pong(p)).await.is_err() { break; }
}
Some(Ok(AxumWs::Pong(_))) => { last_in = Instant::now(); }
Some(Ok(AxumWs::Close(_))) | None => break,
Some(Err(_)) => break,
_ => {}
}
}
}
}
remote.mark_online(&device_id, false);
crate::logger::log_info(
"music-remote",
format!("WS 已断开: {device_name}({ip})").as_str(),
);
let _ = sink.send(AxumWs::Close(None)).await;
}
fn now_ms() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis() as i64)
.unwrap_or(0)
}
/// 队列快照 → WS 消息(`items`/`index`/`total` 展平成顶层字段)。
fn queue_msg(q: &super::proto::QueueSnapshot) -> WsMessage {
WsMessage::Queue {
items: q.items.clone(),
index: q.index,
total: q.total,
}
}
fn touch_last_connected(app: &AppHandle, device_id: &str) {
let music = app.state::<MusicManager>();
let mut settings = music.load_settings();
if let Some(d) = settings
.remote_devices
.iter_mut()
.find(|d| d.id == device_id)
{
d.last_connected_ms = now_ms();
if let Err(e) = music.save_settings(&settings) {
crate::logger::log_warn("music-remote", &format!("更新最后连接时间失败: {e}"));
}
}
}
/// 执行一条控制指令(§5.1 数据流 + §5.2 兜底规则;P1 扩展 Volume/Select 与 isThing 直通)。
async fn dispatch_cmd(
app: &AppHandle,
action: CmdAction,
args: Option<CmdArgs>,
) -> Result<(), String> {
let remote = app.state::<RemoteManager>();
let np = remote.now_playing();
let gsmtc_ok = remote.gsmtc_ok.load(std::sync::atomic::Ordering::Relaxed);
let a = args.clone().unwrap_or_default();
match action {
// seek:Thing 自身直通 AudioEngine(SMTC 回环无 seek 通道);其他会话走 GSMTC
CmdAction::Seek => {
if args.is_none() || a.pos_sec < 0.0 || !a.pos_sec.is_finite() {
return Err("seek 缺少/非法 args.posSec".into());
}
if np.is_thing {
let engine = app.state::<AudioEngine>();
let active = engine.state().active;
crate::logger::log_info(
"music-remote",
&format!("远程 seek(Thing) pos={:.1} 引擎会话={active}", a.pos_sec),
);
// 引擎无会话(重启后只恢复了队列、还没起播)时 seek 是静默空转,
// 手机端会白等保持窗口才回退——如实报错,让手机端立刻复位并提示
if !active {
return Err("电脑端播放器还没开始播放,先起播才能拖动进度".into());
}
engine.seek(a.pos_sec);
} else if gsmtc_ok {
gctl(np.session_id.clone(), action, args).await?;
} else {
return Err("当前模式不支持该会话的 seek".into());
}
}
// 系统主音量(P1 §7):level>0 自动解除静音(volume::set 内处理)
CmdAction::Volume => {
let Some(_) = args else {
return Err("volume 缺少 args.level".into());
};
if !a.level.is_finite() {
return Err("volume args.level 非法".into());
}
let level = a.level;
tokio::task::spawn_blocking(move || super::volume::set(level))
.await
.map_err(|e| format!("音量任务异常: {e}"))??;
}
// 目标会话切换(P1 §7):空 sessionId = 取消覆盖、跟随系统 current
CmdAction::Select => {
if args.is_none() {
return Err("select 缺少 args.sessionId".into());
}
remote.set_selected(&a.session_id);
}
// 选歌(Thing 专属):队列在前端 store,事件交回前端执行
CmdAction::Jump => {
if !np.is_thing {
return Err("只有 Thing 本机播放支持选歌".into());
}
if args.is_none() || a.index < 0 {
return Err("jump 缺少 args.index".into());
}
let total = remote.queue_snapshot().total;
if total > 0 && a.index >= total {
return Err(format!("队列里没有第 {} 首(共 {total} 首)", a.index + 1));
}
app.emit(super::REMOTE_JUMP_EVENT, a.index)
.map_err(|e| format!("派发到前端失败: {e}"))?;
}
// 按钮类:isThing 直通(P1 §7 跳过系统 SMTC 回环);其他会话 GSMTC;再退事件链兜底
_ => {
if np.is_thing {
let name = button_name(action, np.status == super::proto::PlayStatus::Playing)?;
app.emit(SMTC_BUTTON_EVENT, name)
.map_err(|e| format!("派发到前端失败: {e}"))?;
} else if gsmtc_ok {
gctl(np.session_id.clone(), action, args).await?;
} else {
let name = button_name(action, np.status == super::proto::PlayStatus::Playing)?;
app.emit(SMTC_BUTTON_EVENT, name)
.map_err(|e| format!("派发到前端失败: {e}"))?;
}
}
}
// cmd 触发立即推一帧(§6.3 例外)
remote.notify_state_force();
Ok(())
}
/// 按钮动作 → music-smtc-button 事件载荷(与 smtc.rs 的映射一致)。
fn button_name(action: CmdAction, playing: bool) -> Result<&'static str, String> {
Ok(match action {
CmdAction::Play => "play",
CmdAction::Pause => "pause",
CmdAction::Toggle => {
if playing {
"pause"
} else {
"play"
}
}
CmdAction::Next => "next",
CmdAction::Prev => "prev",
CmdAction::Stop => "stop",
_ => return Err("该动作不支持事件派发".into()),
})
}
/// GSMTC 控制:`.get()` 阻塞等待放 spawn_blocking(§3.1,绝不占 tokio worker/主线程)。
async fn gctl(
session_id: String,
action: CmdAction,
args: Option<CmdArgs>,
) -> Result<(), String> {
tokio::task::spawn_blocking(move || glsmtc::control(&session_id, action, args))
.await
.map_err(|e| format!("控制任务异常: {e}"))?
}
+57
View File
@@ -0,0 +1,57 @@
//! 系统主音量(MUSIC_REMOTE_PLAN P1 §7):MMDevice 默认输出端点的
//! `IAudioEndpointVolume`。
//!
//! 设计取舍:每次调用**现取 COM 对象**(CoCreate + Activate,µs 级开销),
//! 不跨线程持有接口指针——避开 windows-rs 接口的 Send/Sync 争议;
//! 调用频率受控(监视线程 500ms 读一次 + 手机拖动结束发一次 set)。
use windows::core::GUID;
use windows::Win32::Foundation::BOOL;
use windows::Win32::Media::Audio::Endpoints::IAudioEndpointVolume;
use windows::Win32::Media::Audio::{eMultimedia, eRender, IMMDevice, IMMDeviceEnumerator};
use windows::Win32::System::Com::{CLSCTX_ALL, CoCreateInstance};
/// CLSID_MMDeviceEnumerator(mmdevapi.h 固定值)
fn clsid_mm_device_enumerator() -> GUID {
GUID::from_u128(0xBCDE0395_E52F_467C_8E3D_C4579291_692E)
}
fn endpoint() -> Result<IAudioEndpointVolume, String> {
unsafe {
let enumerator: IMMDeviceEnumerator =
CoCreateInstance(&clsid_mm_device_enumerator(), None, CLSCTX_ALL)
.map_err(|e| format!("MMDeviceEnumerator 创建失败: {e}"))?;
let device: IMMDevice = enumerator
.GetDefaultAudioEndpoint(eRender, eMultimedia)
.map_err(|e| format!("默认音频输出端点不可用: {e}"))?;
device
.Activate(CLSCTX_ALL, None)
.map_err(|e| format!("IAudioEndpointVolume 激活失败: {e}"))
}
}
/// 读主音量(0.0~1.0)与静音位;端点不可用返回 None(NowPlaying.volume 置空)。
pub fn read() -> Option<(f64, bool)> {
let vol = endpoint().ok()?;
unsafe {
let v = vol.GetMasterVolumeLevelScalar().ok()? as f64;
let muted = vol.GetMute().ok()?.as_bool();
Some((v.clamp(0.0, 1.0), muted))
}
}
/// 设置主音量(0..1 自动 clamp);**level > 0 时顺带解除静音**——
/// 手机拖音量条本意就是"要出声",静音态下拖动即恢复(P1 手机端音量条语义)。
pub fn set(level: f64) -> Result<(), String> {
let vol = endpoint()?;
let l = level.clamp(0.0, 1.0) as f32;
unsafe {
vol.SetMasterVolumeLevelScalar(l, std::ptr::null())
.map_err(|e| format!("设置音量失败: {e}"))?;
if l > 0.0 {
vol.SetMute(BOOL(0), std::ptr::null())
.map_err(|e| format!("解除静音失败: {e}"))?;
}
}
Ok(())
}
+17
View File
@@ -192,6 +192,17 @@ pub async fn music_smtc_update_metadata(
album: String, album: String,
cover_url: Option<String>, cover_url: Option<String>,
) { ) {
// 回填手机遥控的兜底聚合缓存(MUSIC_REMOTE_PLAN §5.2):先记原始值,
// 后面封面下载/转码失败都不影响这份元数据
if let Some(cache) = app.try_state::<super::SmtcMetaCache>() {
if let Ok(mut g) = cache.0.lock() {
*g = super::SmtcMetaSnapshot {
title: title.clone(),
artist: artist.clone(),
album: album.clone(),
};
}
}
// 下载放在 tokio 线程(主线程不能阻塞);失败只跳过封面,不影响标题/歌手/专辑 // 下载放在 tokio 线程(主线程不能阻塞);失败只跳过封面,不影响标题/歌手/专辑
let cover = match cover_url.as_deref().filter(|u| !u.is_empty()) { let cover = match cover_url.as_deref().filter(|u| !u.is_empty()) {
Some(url) => { Some(url) => {
@@ -383,6 +394,12 @@ pub fn music_smtc_update_playback_state(app: AppHandle, playing: bool) {
#[tauri::command] #[tauri::command]
#[specta::specta] #[specta::specta]
pub fn music_smtc_clear(app: AppHandle) { pub fn music_smtc_clear(app: AppHandle) {
// 兜底缓存同步清空(遥控端随下一帧 state 显示"未在播放")
if let Some(cache) = app.try_state::<super::SmtcMetaCache>() {
if let Ok(mut g) = cache.0.lock() {
*g = super::SmtcMetaSnapshot::default();
}
}
on_main(&app, "clear", move |ctrl| { on_main(&app, "clear", move |ctrl| {
let _ = ctrl.SetPlaybackStatus(MediaPlaybackStatus::Stopped); let _ = ctrl.SetPlaybackStatus(MediaPlaybackStatus::Stopped);
if let Ok(updater) = ctrl.DisplayUpdater() { if let Ok(updater) = ctrl.DisplayUpdater() {
+3
View File
@@ -65,6 +65,9 @@ pub fn init(app: &mut App<Wry>) -> Result<(), Box<dyn std::error::Error>> {
music.set_app(app.handle().clone()); music.set_app(app.handle().clone());
app.manage(music); app.manage(music);
// ===== 手机互联:按设置自启(RemoteManager 本体在 lib.rs 平级 manage)=====
crate::music::init_on_launch(app.handle());
// ===== AI 模块:AiManager(全局供应商配置,主设置 → AI 服务)===== // ===== AI 模块:AiManager(全局供应商配置,主设置 → AI 服务)=====
// 迁移必须在建 State 之前跑:把旧版存在翻译设置里的 AI 引擎(含密钥)搬过来, // 迁移必须在建 State 之前跑:把旧版存在翻译设置里的 AI 引擎(含密钥)搬过来,
// 否则 AiManager 预热缓存时会读走默认配置。迁移逻辑在 translate 侧(要同时读懂 // 否则 AiManager 预热缓存时会读走默认配置。迁移逻辑在 translate 侧(要同时读懂
+146
View File
@@ -286,6 +286,62 @@ export const commands = {
musicAudioSetVolume: (volume: number | null, muted: boolean) => __TAURI_INVOKE<void>("music_audio_set_volume", { volume, muted }), musicAudioSetVolume: (volume: number | null, muted: boolean) => __TAURI_INVOKE<void>("music_audio_set_volume", { volume, muted }),
/** 读取播放状态快照(位置/缓冲/采样率/是否失败)。 */ /** 读取播放状态快照(位置/缓冲/采样率/是否失败)。 */
musicAudioState: () => __TAURI_INVOKE<AudioState>("music_audio_state"), musicAudioState: () => __TAURI_INVOKE<AudioState>("music_audio_state"),
remoteGetConfig: () => __TAURI_INVOKE<RemoteConfig>("remote_get_config"),
/** 开关(即时生效,§5.1)。 */
remoteSetEnabled: (enabled: boolean) => __TAURI_INVOKE<RemoteConfig>("remote_set_enabled", { enabled }),
remoteStatus: () => __TAURI_INVOKE<RemoteStatus>("remote_status"),
/** 生成配对码 + 二维码 payload(前端 `qrcode` 渲染,§5.3)。 */
remoteStartPairing: () => __TAURI_INVOKE<RemotePairingInfo>("remote_start_pairing"),
remoteCancelPairing: () => __TAURI_INVOKE<void>("remote_cancel_pairing"),
/** 设备列表(元数据 + 在线态;token 永不出现在这里)。 */
remoteListDevices: () => __TAURI_INVOKE<RemoteDeviceView[]>("remote_list_devices"),
/** 吊销设备(删表 + 删凭据;已建立的 WS 在下次重连时被拒)。 */
remoteRevokeDevice: (id: string) => __TAURI_INVOKE<null>("remote_revoke_device", { id }),
/**
* 前端发布 Thing 本机播放队列(手机端「播放队列 / 选歌」的数据源)。
*
* 队列活在前端 store(feiniuStore),Rust 只做快照转发;`items` 允许是完整队列
* 的一段(见 [`proto::QueueItem::index`]),`total` 恒为完整长度。
*/
remotePublishQueue: (items: QueueItem[], index: number, total: number) => __TAURI_INVOKE<void>("remote_publish_queue", { items, index, total }),
/**
* 启动一批本地解密任务。
*
* 两种输入方式(二选一,`folder` 优先):
* - `folder`:**文件夹批量**。递归扫描该目录下所有可解密的加密音乐
* (内容判定优先,见 `scan::route`),并按 `root` 还原相对目录结构。
* - `files`:显式文件列表(散选场景)。
*
* `in_place = true` 时产物与源文件同目录同名——文件夹批量推荐这样用,
* 符合"就地解出来"的直觉;`false` 则统一输出到 `out_dir`。
*
* 返回 `Ok(())` 表示任务已登记并开始执行;逐文件结果走事件。
*/
musicDecryptRun: (taskId: string, files: string[] | null, folder: string | null, root: string | null, outDir: string | null, inPlace: boolean | null) => __TAURI_INVOKE<null>("music_decrypt_run", { taskId, files, folder, root, outDir, inPlace }),
/**
* 请求取消一个解密任务。
*
* 队列级语义(与 `music_download_cancel` 一致):**当前文件会做完**,
* 剩余文件不再开始处理,随后发一个带 `cancelled` 计数的 `finished` 事件。
* 返回是否命中了一个在跑的任务(false 通常表示任务已结束)。
*/
musicDecryptCancel: (taskId: string) => __TAURI_INVOKE<boolean>("music_decrypt_cancel", { taskId }),
/**
* 扫描一个文件夹,返回可解密文件的数量与平台分布(**不解密**)。
*
* 给 UI 做预览:用户选完文件夹先看到"找到 N 个(网易云 x / QQ音乐 y)",
* 而不是直接开跑一个可能包含几千首的任务。
*/
musicDecryptScan: (folder: string, root: string | null) => __TAURI_INVOKE<ScanSummary>("music_decrypt_scan", { folder, root }),
/**
* 探测 QQ 音乐**在线取密钥**能力(新版 musicex 文件解密的前置条件)。
*
* 只读本机信息,不发网络请求:读 `QQMusicServiceConfig.ini` 的 `uin`,
* 再从运行中的 `QQMusic.exe` 内存里找 `authst`。
*
* `authst` **不会**返回给前端(只在后端用于调接口),前端拿到的只有 QQ 号与状态。
*/
musicDecryptQqStatus: () => __TAURI_INVOKE<QqOnlineStatus>("music_decrypt_qq_status"),
/** 禁用指定窗口(按 label 查找)的显示/隐藏过渡动画,消除覆盖层出现/消失时的缩放动画 */ /** 禁用指定窗口(按 label 查找)的显示/隐藏过渡动画,消除覆盖层出现/消失时的缩放动画 */
screenshotDisableTransitions: (label: string) => __TAURI_INVOKE<null>("screenshot_disable_transitions", { label }), screenshotDisableTransitions: (label: string) => __TAURI_INVOKE<null>("screenshot_disable_transitions", { label }),
/** 一次 IPC 完成指定窗口的显示与聚焦(截图覆盖层显示关键路径,减少串行往返) */ /** 一次 IPC 完成指定窗口的显示与聚焦(截图覆盖层显示关键路径,减少串行往返) */
@@ -1721,6 +1777,14 @@ export type MusicSettings = {
feiniuLibraryNasPath?: string, feiniuLibraryNasPath?: string,
/** 下载完成后自动上传到飞牛曲库 */ /** 下载完成后自动上传到飞牛曲库 */
feiniuAutoUpload?: boolean, feiniuAutoUpload?: boolean,
/** 手机互联:总开关(变更即时生效,MUSIC_REMOTE_PLAN §5.1) */
remoteEnabled?: boolean,
/** 手机互联:期望端口(0 = 默认 26124 起自动探测至 26139) */
remotePort?: number,
/** 本机标识(beacon / NowPlaying.deviceId 同源;首次启动自动生成) */
remoteDeviceId?: string,
/** 已配对设备表(仅元数据;token 在系统凭据管理器 `music-remote-token-*`) */
remoteDevices?: RemoteDeviceMeta[],
}; };
/** 划词结果悬浮窗外观(P1 生效)。 */ /** 划词结果悬浮窗外观(P1 生效)。 */
@@ -1809,6 +1873,35 @@ export type ProxyStatus = {
restartCount: number, restartCount: number,
}; };
/** 在线能力状态(给 UI 状态卡用) */
export type QqOnlineStatus = {
/** QQMusic.exe 是否在运行 */
running: boolean,
/** 是否取到了 authst(= 已登录且能读到内存) */
loggedIn: boolean,
/** 本机读到的 QQ 号(仅用于展示;没有则为 None) */
uin: string | null,
/** 是否具备在线取 ekey 的能力 */
ready: boolean,
/** 给用户的一句话状态 */
message: string,
/** 需要用户照做的步骤(ready 时为一条"无需额外设置") */
steps: string[],
};
/**
* 播放队列条目(Thing 专属:本机播放器的队列,手机端可选歌)。
*
* `index` 是**在完整队列里的绝对下标**——下发时允许只带当前附近的一段
* (前端最多推 500 条,见 feiniuStore),手机端跳歌直接把 index 回传。
*/
export type QueueItem = {
index: number,
title: string,
artist: string,
durationSec: number | null,
};
/** 快速面板设置 */ /** 快速面板设置 */
export type QuickPanelSettings = { export type QuickPanelSettings = {
/** 全局快捷键(如 "Alt+Space"),空字符串表示不注册。 */ /** 全局快捷键(如 "Alt+Space"),空字符串表示不注册。 */
@@ -1823,6 +1916,52 @@ export type QuickPanelSettings = {
customCommands?: CustomCommand[], customCommands?: CustomCommand[],
}; };
/** 远程配置(§5.1 命令 `remote_get_config` / `remote_set_enabled`)。 */
export type RemoteConfig = {
/** 开关(持久化) */
enabled: boolean,
/** 期望端口(0 = 默认 26124 起自动探测) */
port: number,
/** 服务是否在运行 */
running: boolean,
/** 实际监听端口(未运行为 0) */
runningPort: number,
/** 本机标识(beacon / NowPlaying.deviceId 同源) */
deviceId: string,
};
/** 设备元数据(settings.json 持久化;**token 不在此**,见键名约定)。 */
export type RemoteDeviceMeta = {
id: string,
name: string,
/** 最后一次成功连接(Unix 毫秒;0 = 从未连接) */
lastConnectedMs?: number,
};
/** 设备视图(settings 元数据 + 在线态)。 */
export type RemoteDeviceView = {
id: string,
name: string,
lastConnectedMs: number,
online: boolean,
};
/** 进行中的配对信息(二维码 payload 见计划 §3.3 扫码行)。 */
export type RemotePairingInfo = {
code: string,
/** `thingmusic://connect?ip=…&port=…&code=…` */
qrPayload: string,
secondsLeft: number,
};
/** 服务状态(`remote_status`)。 */
export type RemoteStatus = {
running: boolean,
port: number,
online: RemoteDeviceView[],
pairing: RemotePairingInfo | null,
};
export type RenameItem = { export type RenameItem = {
path: string, path: string,
oldName: string, oldName: string,
@@ -1843,6 +1982,13 @@ export type RenameResult = {
error: string, error: string,
}; };
/** `music_decrypt_scan` 的返回(前端零手写类型) */
export type ScanSummary = {
total: number,
ncm: number,
qmc: number,
};
export type ScreenRect = { export type ScreenRect = {
x: number, x: number,
y: number, y: number,
+25
View File
@@ -19,6 +19,7 @@ import {
Plus, Plus,
RotateCw, RotateCw,
Search, Search,
Smartphone,
Square, Square,
Trash2, Trash2,
Upload, Upload,
@@ -39,8 +40,10 @@ import { commands } from '@/lib/bindings'
import { sourceName, PICKER_SOURCES } from './sources' import { sourceName, PICKER_SOURCES } from './sources'
import SourcePicker from './SourcePicker.vue' import SourcePicker from './SourcePicker.vue'
import MyMusicLibrary from './components/MyMusicLibrary.vue' import MyMusicLibrary from './components/MyMusicLibrary.vue'
import DecryptPanel from './components/DecryptPanel.vue'
import ConnectionsSettings from './components/settings/ConnectionsSettings.vue' import ConnectionsSettings from './components/settings/ConnectionsSettings.vue'
import CacheSettings from './components/settings/CacheSettings.vue' import CacheSettings from './components/settings/CacheSettings.vue'
import RemoteSettings from './components/settings/RemoteSettings.vue'
import { Button } from '@/components/ui/button' import { Button } from '@/components/ui/button'
import { Badge } from '@/components/ui/badge' import { Badge } from '@/components/ui/badge'
import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card' import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
@@ -76,6 +79,7 @@ const activeTab = ref('mymusic')
useModuleTabs('music', activeTab, [ useModuleTabs('music', activeTab, [
{ value: 'mymusic', label: '曲库' }, { value: 'mymusic', label: '曲库' },
{ value: 'discover', label: '发现音乐' }, { value: 'discover', label: '发现音乐' },
{ value: 'decrypt', label: '解密' },
{ value: 'settings', label: '设置' } { value: 'settings', label: '设置' }
], { alwaysVisible: true }) ], { alwaysVisible: true })
@@ -1263,6 +1267,11 @@ const RESULT_GRID = { gridTemplateColumns: '24px 36px minmax(0,1fr) 108px 52px 9
</div> </div>
</TabsContent> </TabsContent>
<!-- ===== 解密(本地加密音乐文件解密) ===== -->
<TabsContent value="decrypt" class="min-h-0 flex-1 flex flex-col tab-animate">
<DecryptPanel />
</TabsContent>
<!-- ===== 设置(与其他模块一致的 Card 卡片式布局) ===== --> <!-- ===== 设置(与其他模块一致的 Card 卡片式布局) ===== -->
<TabsContent value="settings" class="min-h-0 flex-1 tab-animate"> <TabsContent value="settings" class="min-h-0 flex-1 tab-animate">
<div> <div>
@@ -1283,6 +1292,22 @@ const RESULT_GRID = { gridTemplateColumns: '24px 36px minmax(0,1fr) 108px 52px 9
</CardContent> </CardContent>
</Card> </Card>
<!-- 手机互联(MUSIC_REMOTE_PLAN:发现/配对/设备管理) -->
<Card>
<CardHeader>
<CardTitle class="flex items-center gap-2 text-base">
<Smartphone class="size-4 text-primary" />
手机互联
</CardTitle>
</CardHeader>
<CardContent class="flex flex-col gap-3">
<p class="text-xs text-muted-foreground">
手机上的 LFMusic 自动发现并连接本机,显示当前播放、远程控制(播放/暂停/切歌/进度)。
</p>
<RemoteSettings />
</CardContent>
</Card>
<!-- 存储与上传 --> <!-- 存储与上传 -->
<Card> <Card>
<CardHeader> <CardHeader>
@@ -0,0 +1,505 @@
<script setup lang="ts">
import { computed, onMounted, ref } from 'vue'
import { toast } from 'vue-sonner'
import { open as openDialog } from '@tauri-apps/plugin-dialog'
import { revealItemInDir } from '@tauri-apps/plugin-opener'
import {
CircleAlert,
CircleCheck,
CloudDownload,
FileAudio,
FolderOpen,
FolderSearch,
Image,
Loader2,
Play,
RotateCw,
Trash2,
TriangleAlert,
X
} from '@lucide/vue'
import { useDecryptStore, type DecryptRow, type DecryptTask } from '@/stores/decryptStore'
import { useMusicStore } from '@/stores/musicStore'
import { Button } from '@/components/ui/button'
import { Input } from '@/components/ui/input'
import { Progress } from '@/components/ui/progress'
import { ScrollArea } from '@/components/ui/scroll-area'
import { Switch } from '@/components/ui/switch'
import { Label } from '@/components/ui/label'
import { StateBlock, StatusBadge, StatusDot } from '@/components/common'
const store = useDecryptStore()
const music = useMusicStore()
/**
* 支持的后缀,仅用于文件对话框的过滤器。
*
* **真正的平台判定在 Rust 侧按内容做**(`scan::route`:先看 ncm 头部魔数、
* 再看 QMC 尾部形态),所以文件夹扫描不依赖这张表——它只是让散选时
* 用户能一眼看到哪些格式可选。
*/
const NCM_EXT = ['ncm']
const QQ_EXT = [
'mgg',
'mgg0',
'mgg1',
'mggl',
'mflac',
'mflac0',
'mflach',
'mmp4',
'qmc0',
'qmc2',
'qmc3',
'qmcflac',
'qmcogg'
]
/** 输出目录:默认 `savedir/decrypted`,允许本次会话内改(不落盘,见计划 §8) */
const outDirOverride = ref('')
const defaultOutDir = computed(() => {
const base = music.settings?.savedir ?? ''
if (!base) return ''
return `${base.replace(/[\\/]+$/, '')}\\decrypted`
})
const outDir = computed(() => outDirOverride.value || defaultOutDir.value)
/** 就地解密:产物写在源文件同目录。文件夹批量默认开启(见 §4.4) */
const inPlace = ref(true)
/** 已选文件夹与扫描预览 */
const pickedFolder = ref('')
const scanning = ref(false)
const scanPreview = ref<{ total: number; ncm: number; qmc: number } | null>(null)
const latest = computed<DecryptTask | null>(() => store.tasks[0] ?? null)
const busy = computed(() => store.hasRunning)
onMounted(() => {
// 监听挂 store:本组件会随 Tabs 切换被卸载重建,事件不能绑在组件生命周期上
void store.ensureListener()
// QQ 在线能力探测:只读本机信息,代价很小,进页签就探一次
void store.probeQq()
})
/** 在线能力状态卡是否展开(折叠后不干扰日常使用) */
const qqStepsOpen = ref(false)
/** 默认只在未就绪时展开步骤,避免占地方 */
const showQqSteps = computed(() => qqStepsOpen.value || !store.qqStatus?.ready)
async function redetectQq() {
const s = await store.probeQq()
if (!s) {
toast.error('检测失败,请查看日志')
} else if (s.ready) {
toast.success('QQ 音乐在线解密已就绪')
} else {
toast.warning(s.message)
}
}
async function pickFolder() {
const picked = await openDialog({
directory: true,
title: '选择要批量解密的文件夹'
})
if (!picked) return
const dir = String(picked)
pickedFolder.value = dir
scanPreview.value = null
scanning.value = true
try {
const summary = await store.scanFolder(dir, dir)
scanPreview.value = summary
if (summary.total === 0) {
toast.warning('该文件夹里没有找到可解密的加密音乐文件')
}
} catch (e) {
toast.error(`扫描文件夹失败:${e}`)
} finally {
scanning.value = false
}
}
async function startFolder() {
if (!pickedFolder.value) return
await start({ folder: pickedFolder.value, root: pickedFolder.value })
}
async function pickFiles() {
const picked = await openDialog({
multiple: true,
title: '选择要解密的音乐文件',
filters: [
{ name: '加密音乐(网易云 / QQ音乐)', extensions: [...NCM_EXT, ...QQ_EXT] },
{ name: '网易云 .ncm', extensions: NCM_EXT },
{ name: 'QQ音乐 QMC 系列', extensions: QQ_EXT }
]
})
if (!picked) return
const files = (Array.isArray(picked) ? picked : [picked]).map(String)
await start({ files })
}
async function start(input: { files?: string[]; folder?: string; root?: string }) {
// 就地模式不需要输出目录;非就地模式必须有
if (!inPlace.value && !outDir.value) {
toast.error('请先在「设置」里配置本地下载目录,或在此指定输出目录')
return
}
try {
await store.run({
files: input.files,
folder: input.folder,
root: input.root,
outDir: outDir.value,
inPlace: inPlace.value
})
} catch (e) {
toast.error(`启动失败:${e}`)
}
}
async function pickOutDir() {
const picked = await openDialog({ directory: true, title: '选择解密输出目录' })
if (picked) outDirOverride.value = String(picked)
}
async function cancel() {
const t = latest.value
if (!t || t.status !== 'running') return
await store.cancel(t.taskId)
toast.info('已请求取消,当前文件完成后停止')
}
async function reveal(path?: string) {
if (!path) return
try {
await revealItemInDir(path)
} catch (e) {
toast.error(`打开所在目录失败:${e}`)
}
}
async function revealTaskDir(t: DecryptTask) {
const first = t.rows.find((r) => r.output)?.output
if (first) return reveal(first)
// 就地模式没有产物时退回源目录
if (t.folder) return reveal(t.folder)
toast.info('该任务还没有产出文件')
}
function rowStatusVariant(s: DecryptRow['status']): 'success' | 'danger' | 'warning' | 'neutral' | 'accent' {
if (s === 'ok') return 'success'
if (s === 'error') return 'danger'
if (s === 'unsupported') return 'warning'
if (s === 'running') return 'accent'
return 'neutral'
}
function rowStatusText(s: DecryptRow['status']): string {
return { pending: '待解密', running: '解密中', ok: '成功', error: '失败', unsupported: '不支持' }[s]
}
/** 平台徽标:优先按路径后缀;文件夹模式下路径可能只有文件名 */
function platformOf(row: DecryptRow): '网易云' | 'QQ音乐' | '—' {
const ext = row.path.split('.').pop()?.toLowerCase() ?? row.name.split('.').pop()?.toLowerCase() ?? ''
if (ext === 'ncm') return '网易云'
if (QQ_EXT.includes(ext)) return 'QQ音乐'
return '—'
}
/** 任务级进度百分比(按已完成文件数,不按字节——字节进度是单文件内的) */
function taskPercent(t: DecryptTask): number {
if (t.total === 0) return 0
return Math.round((t.done / t.total) * 100)
}
function fmtBytes(n: number): string {
if (!n) return '—'
const mb = n / 1024 / 1024
return mb >= 1 ? `${mb.toFixed(1)} MB` : `${Math.round(n / 1024)} KB`
}
const titleOf = (t: DecryptTask) => {
if (t.status === 'running') return `解密中 · ${t.done}/${t.total}`
if (t.status === 'cancelled') return `已取消 · 成功 ${t.ok} / 失败 ${t.failed}`
return `已完成 · 成功 ${t.ok} / 失败 ${t.failed}`
}
/** 文件夹模式下给任务行加相对目录前缀,便于区分同名文件 */
function displayName(row: DecryptRow): string {
if (!row.path) return row.name
return row.path
}
</script>
<template>
<div class="flex min-h-0 flex-1 flex-col gap-3">
<!-- 操作行 -->
<div class="flex flex-wrap items-center gap-2">
<Button size="sm" :disabled="busy" @click="pickFolder">
<FolderSearch class="size-3.5" />
<span class="ml-1.5">选择文件夹</span>
</Button>
<Button variant="outline" size="sm" :disabled="busy" @click="pickFiles">
<FileAudio class="size-3.5" />
<span class="ml-1.5">选择文件</span>
</Button>
<span class="flex items-center gap-1.5 rounded-md border px-2 py-1">
<Switch id="decrypt-inplace" v-model="inPlace" class="scale-90" />
<Label for="decrypt-inplace" class="cursor-pointer text-[11.5px]">就地解密</Label>
</span>
<Button v-if="busy" variant="outline" size="sm" @click="cancel">
<X class="size-3.5" />
<span class="ml-1.5">取消</span>
</Button>
<Button
v-if="store.tasks.some((t) => t.status !== 'running')"
variant="ghost"
size="sm"
@click="store.clearFinished()"
>
<Trash2 class="size-3.5" />
<span class="ml-1.5">清空记录</span>
</Button>
</div>
<!-- 输出目录(就地模式下置灰,因为它不参与写盘) -->
<div class="flex items-center gap-1.5">
<span class="shrink-0 text-[11.5px] text-muted-foreground">输出目录</span>
<Input
:model-value="inPlace ? '与源文件同目录(就地解密)' : outDir"
readonly
:disabled="inPlace"
class="h-8 min-w-0 flex-1 text-[11.5px]"
placeholder="未配置下载目录"
/>
<Button
variant="outline"
size="icon"
class="size-8 shrink-0"
:disabled="inPlace"
title="选择输出目录"
@click="pickOutDir"
>
<FolderOpen class="size-3.5" />
</Button>
</div>
<!-- QQ 音乐在线解密能力(新版 musicex 的前置条件) -->
<div class="rounded-lg border bg-card px-3 py-2">
<div class="flex flex-wrap items-center gap-2 text-[12px]">
<StatusDot
:state="store.qqStatus?.ready ? 'success' : store.qqStatus?.running ? 'warning' : 'neutral'"
:pulse="store.qqProbing"
/>
<span class="font-medium">QQ 音乐在线解密</span>
<span class="min-w-0 flex-1 truncate text-[11.5px] text-muted-foreground">
<template v-if="store.qqProbing">检测中…</template>
<template v-else-if="store.qqStatus">
{{ store.qqStatus.message }}
<template v-if="store.qqStatus.uin">(QQ {{ store.qqStatus.uin }})</template>
</template>
<template v-else>尚未检测</template>
</span>
<Button
variant="ghost"
size="sm"
class="shrink-0"
:disabled="store.qqProbing"
@click="redetectQq"
>
<RotateCw class="size-3.5" :class="store.qqProbing && 'animate-spin'" />
<span class="ml-1.5">重新检测</span>
</Button>
<Button
v-if="store.qqStatus && !store.qqStatus.ready"
variant="ghost"
size="sm"
class="shrink-0"
@click="qqStepsOpen = !qqStepsOpen"
>
{{ showQqSteps ? '收起步骤' : '怎么做?' }}
</Button>
</div>
<!-- 步骤说明 -->
<ol v-if="showQqSteps && store.qqStatus" class="mt-2 flex flex-col gap-1 border-t pt-2">
<li
v-for="(step, i) in store.qqStatus.steps"
:key="i"
class="text-[11.5px] leading-relaxed text-muted-foreground"
>
{{ step }}
</li>
</ol>
<p
v-if="showQqSteps && store.qqStatus && !store.qqStatus.ready"
class="mt-1.5 text-[11.5px] leading-relaxed text-muted-foreground"
>
说明:旧版下载的 <span class="text-foreground">.qmcflac / .mgg / .mflac</span>(尾部内嵌密钥)
以及所有 <span class="text-foreground">.ncm</span> 都<span class="text-foreground">不需要登录</span>,
现在就能离线解密。只有 QQ 客户端 19.57 以上的新版
<span class="text-foreground">musicex</span> 格式才需要上面这些步骤。
</p>
</div>
<!-- 文件夹扫描预览 -->
<div
v-if="pickedFolder"
class="flex flex-wrap items-center gap-2 rounded-lg border bg-card px-3 py-2 text-[12px]"
>
<FolderSearch class="size-3.5 shrink-0 text-muted-foreground" />
<span class="min-w-0 flex-1 truncate" :title="pickedFolder">{{ pickedFolder }}</span>
<template v-if="scanning">
<Loader2 class="size-3.5 animate-spin text-primary" />
<span class="text-[11.5px] text-muted-foreground">扫描中…</span>
</template>
<template v-else-if="scanPreview">
<span class="tabular-nums text-[11.5px] text-muted-foreground">
找到 {{ scanPreview.total }} 个 · 网易云 {{ scanPreview.ncm }} · QQ音乐 {{ scanPreview.qmc }}
</span>
<Button size="sm" :disabled="busy || scanPreview.total === 0" @click="startFolder">
<Play class="size-3.5" />
<span class="ml-1.5">开始解密</span>
</Button>
</template>
<template v-else>
<span class="flex items-center gap-1 text-[11.5px] text-warning-text">
<TriangleAlert class="size-3.5" />未扫描
</span>
</template>
</div>
<!-- 任务区 -->
<div class="flex min-h-0 flex-1 flex-col gap-3 overflow-hidden">
<StateBlock
v-if="store.tasks.length === 0"
variant="empty"
title="还没有解密任务"
description="选择文件夹可批量解密整个目录(递归、保留目录结构);也可散选文件。支持网易云 .ncm 与 QQ音乐 QMC 系列,全部在本机离线完成。"
>
<template #action>
<div class="flex items-center gap-2">
<Button size="sm" :disabled="busy" @click="pickFolder">
<FolderSearch class="size-3.5" />
<span class="ml-1.5">选择文件夹</span>
</Button>
<Button variant="outline" size="sm" :disabled="busy" @click="pickFiles">
<FileAudio class="size-3.5" />
<span class="ml-1.5">选择文件</span>
</Button>
</div>
</template>
</StateBlock>
<ScrollArea v-else class="min-h-0 flex-1">
<div class="flex flex-col gap-3 pr-2">
<div v-for="t in store.tasks" :key="t.taskId" class="rounded-lg border bg-card">
<!-- 任务头 -->
<div class="flex items-center gap-2 border-b px-3 py-2">
<Loader2 v-if="t.status === 'running'" class="size-3.5 shrink-0 animate-spin text-primary" />
<CircleCheck v-else-if="t.status === 'done'" class="size-3.5 shrink-0 text-success" />
<CircleAlert v-else class="size-3.5 shrink-0 text-warning" />
<span class="text-[12.5px] font-medium">{{ titleOf(t) }}</span>
<span class="min-w-0 truncate text-[11.5px] text-muted-foreground" :title="t.folder">
{{ t.folder ? t.folder : `共 ${t.total} 个文件` }}
</span>
<span class="ml-auto flex items-center gap-2">
<span class="text-[11.5px] text-muted-foreground tabular-nums">
<template v-if="t.status === 'running' && t.bytesTotal > 0">
{{ fmtBytes(t.bytesDone) }} / {{ fmtBytes(t.bytesTotal) }}
</template>
<template v-else>{{ t.done }}/{{ t.total }}</template>
</span>
<Button
variant="ghost"
size="icon"
class="size-7"
title="打开产物所在目录"
@click="revealTaskDir(t)"
>
<FolderOpen class="size-3.5" />
</Button>
<Button
v-if="t.status !== 'running'"
variant="ghost"
size="icon"
class="size-7"
title="移除记录"
@click="store.remove(t.taskId)"
>
<X class="size-3.5" />
</Button>
</span>
</div>
<!-- 进度条:结构恒定——任务结束后保留(满格),不整块消失 -->
<div class="px-3 pt-2">
<Progress :model-value="taskPercent(t)" class="h-1.5" />
</div>
<!-- 文件行 -->
<div class="divide-y">
<div
v-for="row in t.rows"
:key="row.index"
class="flex items-center gap-2 px-3 py-1.5 text-[12px]"
>
<span class="min-w-0 flex-1 truncate" :title="displayName(row)">{{ row.name }}</span>
<span class="shrink-0 text-[11.5px] text-muted-foreground">{{ platformOf(row) }}</span>
<StatusBadge :variant="rowStatusVariant(row.status)" size="sm">
{{ rowStatusText(row.status) }}
</StatusBadge>
<Button
v-if="row.output"
variant="ghost"
size="icon"
class="size-7 shrink-0"
title="打开产物所在目录"
@click="reveal(row.output)"
>
<FolderOpen class="size-3.5" />
</Button>
<span v-else class="size-7 shrink-0" />
<!-- 封面单独落盘:也给它一个入口,否则用户不知道它在哪 -->
<Button
v-if="row.cover"
variant="ghost"
size="icon"
class="size-7 shrink-0 text-muted-foreground"
title="打开封面所在目录"
@click="reveal(row.cover)"
>
<Image class="size-3.5" />
</Button>
<span v-else class="size-7 shrink-0" />
<!-- 成功时是备注(平台/密钥形态),失败时是原因 -->
<span
v-if="row.message"
class="max-w-[45%] shrink-0 truncate text-[11.5px]"
:class="row.status === 'ok' ? 'text-muted-foreground' : 'text-danger-text'"
:title="row.message"
>
{{ row.message }}
</span>
</div>
</div>
</div>
</div>
</ScrollArea>
</div>
<!-- 合规说明 -->
<p class="flex items-start gap-1.5 text-[11.5px] leading-relaxed text-muted-foreground">
<CloudDownload class="mt-0.5 size-3 shrink-0" />
仅处理你本人拥有合法访问权限的本地文件,请勿用于批量分发或规避付费授权。QQ音乐加密文件按内容识别(QMC1 固定密钥 / QMC2 尾部内嵌 ekey 可离线解密;新版 musicex 需登录 QQ 音乐联网取密钥,暂未支持)。
</p>
</div>
</template>
@@ -0,0 +1,249 @@
<script setup lang="ts">
import { computed, onMounted, onUnmounted, ref } from 'vue'
import { toast } from 'vue-sonner'
import { Loader2, QrCode, Smartphone, Trash2 } from '@lucide/vue'
import { invoke } from '@tauri-apps/api/core'
import QRCode from 'qrcode'
import { Button } from '@/components/ui/button'
import { Label } from '@/components/ui/label'
import { Switch } from '@/components/ui/switch'
/** 与 Rust `music::remote` 命令返回值对齐(camelCase;bindings 重生成前手写声明) */
interface RemoteConfig {
enabled: boolean
port: number
running: boolean
runningPort: number
deviceId: string
}
interface RemotePairingInfo {
code: string
qrPayload: string
secondsLeft: number
}
interface RemoteDeviceView {
id: string
name: string
lastConnectedMs: number
online: boolean
}
interface RemoteStatus {
running: boolean
port: number
online: RemoteDeviceView[]
pairing: RemotePairingInfo | null
}
const config = ref<RemoteConfig | null>(null)
const status = ref<RemoteStatus | null>(null)
const devices = ref<RemoteDeviceView[]>([])
const pairing = ref<RemotePairingInfo | null>(null)
const qrDataUrl = ref('')
const busy = ref(false)
const loading = ref(true)
let poll: number | null = null
async function refresh() {
try {
const [c, s, d] = await Promise.all([
invoke<RemoteConfig>('remote_get_config'),
invoke<RemoteStatus>('remote_status'),
invoke<RemoteDeviceView[]>('remote_list_devices'),
])
config.value = c
status.value = s
devices.value = d
const wasPairing = pairing.value !== null
pairing.value = s.pairing
if (s.pairing) {
if (!wasPairing || !qrDataUrl.value) await makeQr(s.pairing.qrPayload)
} else {
qrDataUrl.value = ''
}
} catch (e) {
console.error('remote status refresh failed', e)
} finally {
loading.value = false
}
}
async function makeQr(payload: string) {
try {
qrDataUrl.value = await QRCode.toDataURL(payload, { width: 176, margin: 1 })
} catch (e) {
console.error('QR 生成失败', e)
qrDataUrl.value = ''
}
}
const enabled = computed({
get: () => config.value?.enabled ?? false,
set: (v: boolean) => void toggle(v),
})
async function toggle(v: boolean) {
busy.value = true
try {
config.value = await invoke<RemoteConfig>('remote_set_enabled', { enabled: v })
toast.success(v ? '手机互联已开启,手机 App 可发现本机' : '手机互联已关闭')
if (!v) {
pairing.value = null
qrDataUrl.value = ''
}
await refresh()
} catch (e) {
toast.error(`开启失败:${String(e)}`)
await refresh()
} finally {
busy.value = false
}
}
async function startPairing() {
busy.value = true
try {
const info = await invoke<RemotePairingInfo>('remote_start_pairing')
pairing.value = info
await makeQr(info.qrPayload)
} catch (e) {
toast.error(String(e))
} finally {
busy.value = false
}
}
async function cancelPairing() {
try {
await invoke('remote_cancel_pairing')
} catch (e) {
console.error(e)
}
pairing.value = null
qrDataUrl.value = ''
}
async function revoke(d: RemoteDeviceView) {
if (!window.confirm(`确定吊销「${d.name}」?该设备下次连接需要重新配对。`)) return
try {
await invoke('remote_revoke_device', { id: d.id })
toast.success(`已吊销「${d.name}」`)
await refresh()
} catch (e) {
toast.error(String(e))
}
}
function fmtLast(ms: number): string {
if (!ms) return '从未连接'
return new Date(ms).toLocaleString()
}
onMounted(() => {
void refresh()
poll = window.setInterval(() => void refresh(), 5000)
})
onUnmounted(() => {
if (poll !== null) window.clearInterval(poll)
})
</script>
<template>
<div class="flex flex-col gap-3">
<div v-if="loading" class="flex items-center gap-2 text-xs text-muted-foreground">
<Loader2 class="size-3.5 animate-spin" />
读取手机互联状态…
</div>
<!-- 总开关 -->
<div class="flex items-start justify-between gap-4">
<div class="min-w-0">
<div class="flex items-center gap-2">
<Smartphone class="size-4 text-muted-foreground" />
<Label class="font-medium">手机互联</Label>
</div>
<p class="mt-1 text-[11.5px] text-muted-foreground">
开启后,局域网内的 LFMusic App 会自动发现本机并显示/控制当前播放(歌名、歌手、专辑、封面、进度)。
首次连接需要扫码配对;同一网络下 token 长期有效,可随时在此吊销。
</p>
</div>
<Switch v-model="enabled" class="mt-0.5 shrink-0" :disabled="busy" />
</div>
<!-- 运行状态 -->
<div
v-if="config?.running"
class="flex items-center justify-between rounded-lg border bg-card px-3 py-2 text-[12.5px]"
>
<div class="flex items-center gap-2">
<span class="inline-block size-2 rounded-full" :class="config.running ? 'bg-green-500' : 'bg-muted-foreground/40'" />
<span class="text-muted-foreground">服务运行中</span>
<span class="tabular-nums">ws://0.0.0.0:{{ config.runningPort }}</span>
<span class="text-muted-foreground/80">· 发现广播 :26123</span>
</div>
<span class="text-[11px] text-muted-foreground/80">
防火墙若弹窗,请勾选「专用网络」放行
</span>
</div>
<p v-else-if="config && !config.enabled" class="rounded-lg border border-dashed px-3 py-2 text-[11.5px] text-muted-foreground">
当前关闭。开启后手机端才能发现并连接本机。
</p>
<!-- 配对二维码 -->
<div v-if="pairing" class="flex items-center gap-4 rounded-lg border border-primary/40 bg-primary/5 px-3 py-3">
<img v-if="qrDataUrl" :src="qrDataUrl" class="size-44 rounded bg-white p-1" alt="配对二维码" />
<div class="flex min-w-0 flex-col gap-1.5">
<div class="flex items-center gap-2 text-xs text-muted-foreground">
<QrCode class="size-3.5" />
用手机 App 扫码,或手动输入配对码
</div>
<div class="text-3xl font-semibold tracking-[0.3em] tabular-nums">{{ pairing.code }}</div>
<div class="text-[11.5px] text-muted-foreground">
剩余 {{ Math.floor(pairing.secondsLeft / 60) }}:{{ String(pairing.secondsLeft % 60).padStart(2, '0') }}
· 一次性,成功后自动失效
</div>
<Button variant="outline" size="sm" class="mt-1 self-start" :disabled="busy" @click="cancelPairing">
取消配对
</Button>
</div>
</div>
<div v-else-if="config?.running">
<Button variant="outline" size="sm" :disabled="busy" @click="startPairing">
<QrCode class="mr-1.5 size-3.5" />
连接手机(生成配对码)
</Button>
</div>
<!-- 设备列表 -->
<div v-if="devices.length" class="flex flex-col gap-1.5">
<Label class="text-muted-foreground">已配对设备</Label>
<div
v-for="d in devices"
:key="d.id"
class="flex items-center justify-between gap-3 rounded-lg border bg-card px-3 py-2"
>
<div class="flex min-w-0 items-center gap-2.5">
<span
class="size-2 shrink-0 rounded-full"
:class="d.online ? 'bg-green-500' : 'bg-muted-foreground/30'"
:title="d.online ? '在线' : '离线'"
/>
<span class="truncate text-[13px]">{{ d.name }}</span>
<span class="shrink-0 text-[11px] text-muted-foreground">{{ fmtLast(d.lastConnectedMs) }}</span>
</div>
<Button
variant="ghost"
size="sm"
class="h-7 shrink-0 text-destructive hover:text-destructive"
@click="revoke(d)"
>
<Trash2 class="size-3.5" />
</Button>
</div>
</div>
<p class="text-[11px] text-muted-foreground/80">
协议与发现方式见 MUSIC_REMOTE_PLAN.md;手机端配对一次后,打开 App 即自动连接。
</p>
</div>
</template>
+6
View File
@@ -14,6 +14,12 @@ const searchItems: SearchIndexItem[] = [
keywords: ['发现音乐', '搜索', '下载', '聚合', '在线', '网易云', 'qq', '酷狗'], keywords: ['发现音乐', '搜索', '下载', '聚合', '在线', '网易云', 'qq', '酷狗'],
tab: 'discover' tab: 'discover'
}, },
{
title: '音乐解密',
description: '解密本地加密音乐文件(网易云 .ncm;QQ音乐待支持)',
keywords: ['解密', 'decrypt', 'ncm', '网易云', '加密', 'mflac', 'mgg', 'qmc', '转换', '解锁'],
tab: 'decrypt'
},
{ {
title: '音乐设置', title: '音乐设置',
description: '飞牛连接、播放缓存、下载目录与 Python 环境检查', description: '飞牛连接、播放缓存、下载目录与 Python 环境检查',
+394
View File
@@ -0,0 +1,394 @@
import { defineStore } from 'pinia'
import { computed, ref } from 'vue'
import { listen, type UnlistenFn } from '@tauri-apps/api/event'
import { invoke } from '@tauri-apps/api/core'
import { toast } from 'vue-sonner'
import { createLogger } from '@/lib/logger'
const logger = createLogger('music-decrypt')
/** 与 Rust `music::decrypt::FileStatus` 对应 */
export type DecryptFileStatus = 'ok' | 'error' | 'unsupported'
/** 任务行状态(前端自己的展示态,比 Rust 的 FileStatus 多「进行中」) */
export type DecryptRowStatus = 'pending' | 'running' | DecryptFileStatus
export interface DecryptRow {
/** 0-based,与后端 `file` 事件的 index 对齐 */
index: number
/** 源文件绝对路径 */
path: string
/** 文件名(展示用) */
name: string
status: DecryptRowStatus
/** 失败原因 / 成功时的备注(平台、密钥形态、元数据摘要) */
message?: string
/** 产物路径 */
output?: string
/** 单独落盘的封面路径(网易云 ncm 带内嵌封面时才有) */
cover?: string
}
export interface DecryptTask {
taskId: string
status: 'running' | 'done' | 'cancelled'
total: number
/** 已完成文件数(含失败) */
done: number
ok: number
failed: number
/** 被取消时未处理的文件数 */
cancelled: number
rows: DecryptRow[]
/** 当前文件进度(字节) */
bytesDone: number
bytesTotal: number
/** 当前正在处理的文件名 */
currentName: string
startedAt: number
finishedAt?: number
/** 文件夹批量任务的源目录(散选任务为 undefined) */
folder?: string
}
/** `run()` 的入参 */
export interface RunOptions {
/** 散选的文件列表 */
files?: string[]
/** 文件夹批量:后端递归扫描该目录 */
folder?: string
/** 相对路径基准(还原目录结构用),通常与 folder 相同 */
root?: string
outDir: string
/** 就地解密:产物写在源文件同目录(文件夹批量推荐) */
inPlace?: boolean
}
/** 文件夹扫描预览结果(`music_decrypt_scan`) */
export interface ScanSummary {
total: number
ncm: number
qmc: number
}
/**
* QQ 音乐在线解密能力状态(`music_decrypt_qq_status`)。
*
* 新版 `musicex` 格式的 ekey 不在文件里,必须拿本机已登录凭据联网换取,
* 所以这个状态决定了这部分文件能否解密。`authst` **不会**下发到前端。
*/
export interface QqOnlineStatus {
/** QQMusic.exe 是否在运行 */
running: boolean
/** 是否取到登录令牌(= 已登录且能读到内存) */
loggedIn: boolean
/** 本机 QQ 号(仅展示) */
uin: string | null
/** 是否具备在线取密钥的能力 */
ready: boolean
message: string
/** 需要用户照做的步骤 */
steps: string[]
}
/**
* 与 Rust `music::decrypt::DecryptEvent` 对应(`#[serde(tag = "type", rename_all = "kebab-case")]`)。
* 注意字段名由 serde 原样输出为 camelCase 之外的形式:Rust 侧字段是
* `task_id`/`bytes_done`…,`DecryptEvent` 没加 `rename_all`(只有 tag 加了),
* 所以负载里是 **snake_case**。这里按实际收到的形状声明。
*/
type RawEvent =
| { type: 'start'; task_id: string; total: number }
| {
type: 'file'
task_id: string
index: number
name: string
status: DecryptFileStatus
message: string | null
output: string | null
cover: string | null
}
| {
type: 'progress'
task_id: string
done: number
total: number
bytes_done: number
bytes_total: number
name: string
}
| { type: 'finished'; task_id: string; ok: number; failed: number; cancelled: number }
/** 事件名(与 `constants.rs` 的 `MUSIC_DECRYPT_EVENT` 一致;前端侧沿用硬编码,见 musicStore 同款写法) */
const EVENT = 'music-decrypt-event'
export const useDecryptStore = defineStore('musicDecrypt', () => {
/** 时间倒序(最新任务在最前) */
const tasks = ref<DecryptTask[]>([])
/** 同时保留多少个任务(与下载任务的 MAX_TASKS 量级一致) */
const MAX_TASKS = 20
const activeTask = computed(() => tasks.value.find((t) => t.status === 'running') ?? null)
const hasRunning = computed(() => tasks.value.some((t) => t.status === 'running'))
let unlisten: UnlistenFn | null = null
/**
* 事件监听**必须挂在 store**,不能挂组件:音乐模块的 Tabs 非 active 时会卸载
* `TabsContent`,组件里的监听会随之失效,切回页签就丢进度。
*/
async function ensureListener(): Promise<void> {
if (unlisten) return
unlisten = await listen<RawEvent>(EVENT, (e) => handleEvent(e.payload))
}
function handleEvent(ev: RawEvent): void {
const task = tasks.value.find((t) => t.taskId === ev.task_id)
if (!task) return
if (ev.type === 'start') {
task.total = ev.total
// 补齐到 total:文件夹模式下后端会认领比 UI 预览更多的文件,
// 行数必须跟得上,否则后面的 file 事件找不到行。
while (task.rows.length < ev.total) {
task.rows.push({
index: task.rows.length,
path: '',
name: `#${task.rows.length + 1}`,
status: 'pending' as DecryptRowStatus
})
}
if (task.rows[0] && task.rows[0].status === 'pending') task.rows[0].status = 'running'
return
}
if (ev.type === 'progress') {
task.bytesDone = ev.bytes_done
task.bytesTotal = ev.bytes_total
task.currentName = ev.name
// done 由 progress 与 file 共同推进,取更大值避免回退
if (ev.total > 0) {
task.total = ev.total
task.done = Math.max(task.done, Math.min(ev.done, ev.total))
}
return
}
if (ev.type === 'file') {
// 逐文件事件里的 name 是**权威**的(文件夹模式下前端并不预先知道清单),
// 因此行不存在时按事件补建。
let row = task.rows[ev.index]
if (!row) {
while (task.rows.length <= ev.index) {
task.rows.push({
index: task.rows.length,
path: '',
name: `#${task.rows.length + 1}`,
status: 'pending' as DecryptRowStatus
})
}
row = task.rows[ev.index]
}
row.name = ev.name || row.name
row.status = ev.status
row.message = ev.message ?? undefined
row.output = ev.output ?? undefined
row.cover = ev.cover ?? undefined
task.done = Math.max(task.done, ev.index + 1)
// 成功/失败计数以 finished 为准,这里先按逐文件结果累积(UI 更跟手)
const ok = task.rows.filter((r) => r.status === 'ok').length
const failed = task.rows.filter((r) => r.status === 'error' || r.status === 'unsupported').length
task.ok = ok
task.failed = failed
// 下一行进入「进行中」
const next = task.rows[ev.index + 1]
if (next && next.status === 'pending') next.status = 'running'
return
}
if (ev.type === 'finished') {
task.ok = ev.ok
task.failed = ev.failed
task.cancelled = ev.cancelled
// cancelled 是「尚未处理」的数量;clamp 到 0 防止后端口径变化时进度为负
task.done = Math.max(0, task.total - ev.cancelled)
task.status = ev.cancelled > 0 ? 'cancelled' : 'done'
task.finishedAt = Date.now()
task.bytesDone = 0
task.bytesTotal = 0
task.currentName = ''
for (const row of task.rows) {
if (row.status === 'running' || row.status === 'pending') row.status = 'pending'
}
// 收尾提示:任务表本身也是反馈,但用户可能已切走页签(监听在 store,仍然生效)
if (ev.cancelled > 0) {
toast.info(`解密已取消:成功 ${ev.ok} / 失败 ${ev.failed}`)
} else if (ev.failed > 0) {
toast.warning(`解密完成:成功 ${ev.ok} / 失败 ${ev.failed}`)
} else {
toast.success(`解密完成:共 ${ev.ok} 个文件`)
}
}
}
/**
* 启动一批解密。
*
* `taskId` 由前端生成(与 `music_download` 同款),后端只回 `Ok(())`,
* 逐文件结果全部走事件——所以这里必须**先**把任务与行建好,再 `invoke`,
* 否则第一批事件到达时找不到对应任务会被丢弃。
*
* 两种输入二选一:
* - `folder`:文件夹批量(后端递归扫描,**内容判定优先**,会认领比 UI 列表更多的文件)
* - `files`:显式列表(散选)
*/
async function run(opts: RunOptions): Promise<string> {
const { files, folder, root, outDir, inPlace } = opts
const plainFiles = files ?? []
if (!folder && plainFiles.length === 0) throw new Error('未选择任何文件')
await ensureListener()
// 文件夹模式下列表只用于预建行;真实清单以后端扫描为准,
// 因此这里先按已知信息建行,收到超出的 index 时再补行(见 handleEvent)。
const initial = folder ? [] : plainFiles
const taskId = `decrypt-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
const task: DecryptTask = {
taskId,
status: 'running',
total: initial.length,
done: 0,
ok: 0,
failed: 0,
cancelled: 0,
rows: initial.map((path, index) => ({
index,
path,
name: fileName(path),
status: 'pending' as DecryptRowStatus
})),
bytesDone: 0,
bytesTotal: 0,
currentName: folder ? folderName(folder) : '',
startedAt: Date.now(),
folder: folder ?? undefined
}
tasks.value.unshift(task)
if (tasks.value.length > MAX_TASKS) tasks.value = tasks.value.slice(0, MAX_TASKS)
try {
await invoke('music_decrypt_run', {
taskId,
files: plainFiles.length > 0 ? plainFiles : null,
folder: folder ?? null,
root: root ?? null,
outDir,
inPlace: !!inPlace
})
} catch (e) {
// 命令层拒绝(参数问题 / 全部在输出目录内 / 目录里没有加密文件):任务直接落定为失败
task.status = 'done'
task.failed = Math.max(task.total, 1)
task.finishedAt = Date.now()
if (task.rows.length === 0) {
task.rows.push({
index: 0,
path: folder ?? '',
name: folder ? folderName(folder) : '(未选择文件)',
status: 'error',
message: String(e)
})
task.total = 1
} else {
task.rows.forEach((r) => {
r.status = 'error'
r.message = String(e)
})
}
logger.error(`启动解密任务失败:${e}`)
throw e
}
return taskId
}
/** 请求取消(队列级:当前文件做完,剩余不再开始) */
async function cancel(taskId: string): Promise<void> {
await invoke('music_decrypt_cancel', { taskId })
}
/**
* 预览一个文件夹里有多少可解密文件(不解密)。
*
* 内容判定在 Rust 侧完成(`scan::route`),因此结果比按后缀猜更准——
* 用户能在开跑前看到"找到 N 个(网易云 x / QQ音乐 y)"。
*/
async function scanFolder(folder: string, root?: string): Promise<ScanSummary> {
return (await invoke('music_decrypt_scan', {
folder,
root: root ?? null
})) as ScanSummary
}
/**
* 探测 QQ 音乐在线能力(只读本机信息,不发网络请求)。
* 结果缓存在 store 里,供页签状态卡渲染;用户可手动「重新检测」。
*/
const qqStatus = ref<QqOnlineStatus | null>(null)
const qqProbing = ref(false)
async function probeQq(): Promise<QqOnlineStatus | null> {
qqProbing.value = true
try {
qqStatus.value = (await invoke('music_decrypt_qq_status')) as QqOnlineStatus
return qqStatus.value
} catch (e) {
logger.error(`探测 QQ 音乐在线能力失败:${e}`)
return null
} finally {
qqProbing.value = false
}
}
function clearFinished(): void {
tasks.value = tasks.value.filter((t) => t.status === 'running')
}
function remove(taskId: string): void {
tasks.value = tasks.value.filter((t) => t.taskId !== taskId)
}
/** 停止监听(模块卸载场景;正常使用无需调用) */
function dispose(): void {
unlisten?.()
unlisten = null
}
return {
tasks,
activeTask,
hasRunning,
run,
cancel,
scanFolder,
qqStatus,
qqProbing,
probeQq,
clearFinished,
remove,
dispose,
ensureListener
}
})
/** 从路径取文件名(同时兼容 Windows 反斜杠与 POSIX 斜杠) */
function fileName(path: string): string {
const parts = path.split(/[\\/]/)
return parts[parts.length - 1] || path
}
/** 从目录路径取最后一段作为显示名 */
function folderName(path: string): string {
const trimmed = path.replace(/[\\/]+$/, '')
const parts = trimmed.split(/[\\/]/)
return parts[parts.length - 1] || trimmed
}
+58
View File
@@ -506,6 +506,8 @@ export const useFeiniuStore = defineStore('feiniu', () => {
void ensureCacheStatus() void ensureCacheStatus()
// 系统媒体控件的按钮 → 播放器动作(原生 SMTC 事件,整个应用生命周期只订阅一次) // 系统媒体控件的按钮 → 播放器动作(原生 SMTC 事件,整个应用生命周期只订阅一次)
setupSmtcButtons() setupSmtcButtons()
// 手机遥控选歌事件(同样只订阅一次)
setupRemoteJump()
// 引擎事件(播完 / 失败),同样只订阅一次 // 引擎事件(播完 / 失败),同样只订阅一次
setupAudioEvents() setupAudioEvents()
} }
@@ -1422,6 +1424,21 @@ export const useFeiniuStore = defineStore('feiniu', () => {
playCurrent() playCurrent()
} }
/**
* 跳到队列指定条目(手机遥控「选歌」;`index` 是完整队列的绝对下标)。
* 显式点选不走随机洗牌:用户要哪首就播哪首,同时把当前位置压栈供「上一首」回退。
*/
function jumpTo(index: number) {
if (!Number.isInteger(index) || index < 0 || index >= queue.value.length) return
preview.value = null
dropPendingResume()
if (index !== queueIndex.value) {
historyStack.value.push(queueIndex.value)
}
queueIndex.value = index
playCurrent()
}
/** 跳转到指定秒数(时长未知时不动作,由 UI 提示) */ /** 跳转到指定秒数(时长未知时不动作,由 UI 提示) */
function seek(sec: number) { function seek(sec: number) {
if (!engineActive) return if (!engineActive) return
@@ -1735,6 +1752,42 @@ export const useFeiniuStore = defineStore('feiniu', () => {
}).catch((e) => logger.error(`订阅系统媒体按钮事件失败: ${e}`)) }).catch((e) => logger.error(`订阅系统媒体按钮事件失败: ${e}`))
} }
// ===== 手机遥控:队列下发 + 选歌(Thing 专属) =====
/** 下发给手机的队列片段上限(完整队列可到 4000 条,手机端只展示当前附近一段) */
const REMOTE_QUEUE_MAX = 500
let remoteQueueTimer: ReturnType<typeof setTimeout> | null = null
/** 队列快照去抖下发(每项带绝对 `index`,服务端与手机端按它跳转) */
function publishRemoteQueue() {
if (remoteQueueTimer) clearTimeout(remoteQueueTimer)
remoteQueueTimer = setTimeout(() => {
remoteQueueTimer = null
const all = queue.value
const idx = queueIndex.value
const start =
all.length <= REMOTE_QUEUE_MAX
? 0
: Math.max(0, Math.min(idx - 100, all.length - REMOTE_QUEUE_MAX))
const items = all.slice(start, start + REMOTE_QUEUE_MAX).map((t, i) => ({
index: start + i,
title: t.title || '',
artist: t.artistNames || '',
durationSec: (t.durationMs ?? 0) / 1000
}))
void invoke('remote_publish_queue', { items, index: idx, total: all.length }).catch((e) => {
logger.error(`下发遥控队列失败: ${String(e)}`)
})
}, 300)
}
/** 手机端点选某首 → 跳过去(remote 服务把 `jump` 指令转成事件回来) */
function setupRemoteJump() {
void listen<number>('music-remote-jump', (e) => jumpTo(Number(e.payload))).catch((e) =>
logger.error(`订阅遥控选歌事件失败: ${String(e)}`)
)
}
// 曲目变化 → 元数据;播放/暂停 → 状态。用 watch 统一挂钩,避免在每条切歌分支 // 曲目变化 → 元数据;播放/暂停 → 状态。用 watch 统一挂钩,避免在每条切歌分支
// (队列/试听/恢复播放/缓存播放)里各写一遍而漏掉某条路径。 // (队列/试听/恢复播放/缓存播放)里各写一遍而漏掉某条路径。
watch(nowPlaying, () => { watch(nowPlaying, () => {
@@ -1749,6 +1802,11 @@ export const useFeiniuStore = defineStore('feiniu', () => {
// 系统面板就一直缺封面(歌名/歌手/专辑正常),直到用户切歌才补上。 // 系统面板就一直缺封面(歌名/歌手/专辑正常),直到用户切歌才补上。
// 前缀到位后补投一次元数据即可(coverId 已随队列落盘,无需重取)。 // 前缀到位后补投一次元数据即可(coverId 已随队列落盘,无需重取)。
watch(mediaPrefix, () => syncMediaMetadata()) watch(mediaPrefix, () => syncMediaMetadata())
// 遥控队列下发:切歌 / 增删队列 → 去抖 300ms 发布(Thing 专属能力)。
// 队列可能在这些 watch 挂上之前就恢复好了,启动时补发一次。
watch(queue, publishRemoteQueue, { deep: true })
watch(queueIndex, publishRemoteQueue)
publishRemoteQueue()
const progress = computed(() => (duration.value > 0 ? (position.value / duration.value) * 100 : 0)) const progress = computed(() => (duration.value > 0 ? (position.value / duration.value) * 100 : 0))