细节调整

This commit is contained in:
zhongluofeng committed 2026-09-23 18:29:20 +08:00
1 parent bccd21fde5
commit 79bded1cd2
25 files changed
+2655 -494

No files matched your search

+431 -2
View File
@@ -104,6 +104,28 @@ version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
[[package]]
name = "alsa"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "812947049edcd670a82cd5c73c3661d2e58468577ba8489de58e1a73c04cbd5d"
dependencies = [
"alsa-sys",
"bitflags 2.13.2",
"cfg-if",
"libc",
]
[[package]]
name = "alsa-sys"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ad7569085a265dd3f607ebecce7458eaab2132a84393534c95b18dcbc3f31e04"
dependencies = [
"libc",
"pkg-config",
]
[[package]]
name = "android_system_properties"
version = "0.1.5"
@@ -1153,6 +1175,50 @@ dependencies = [
"libc",
]
[[package]]
name = "coreaudio-rs"
version = "0.14.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7d5d7dca3ebcf65a035582c9ad4385371a9d9ee6537474d2a278f4e1e475bb58"
dependencies = [
"bitflags 2.13.2",
"libc",
"objc2-audio-toolbox",
"objc2-core-audio",
"objc2-core-audio-types",
"objc2-core-foundation",
]
[[package]]
name = "cpal"
version = "0.18.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6f02e8d0327b42d3e2e4ab2119af397344eb9fc54a34bf0ddeaa1277af8681f1"
dependencies = [
"alsa",
"block2",
"coreaudio-rs",
"dasp_sample",
"jni 0.22.4",
"js-sys",
"libc",
"mach2",
"ndk",
"ndk-context",
"num-derive",
"num-traits",
"objc2",
"objc2-audio-toolbox",
"objc2-avf-audio",
"objc2-core-audio",
"objc2-core-audio-types",
"objc2-core-foundation",
"objc2-foundation",
"web-sys",
"windows 0.62.2",
"windows-core 0.62.2",
]
[[package]]
name = "cpubits"
version = "0.1.1"
@@ -1430,6 +1496,12 @@ dependencies = [
"serde",
]
[[package]]
name = "dasp_sample"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
[[package]]
name = "data-encoding"
version = "2.11.1"
@@ -1940,6 +2012,12 @@ dependencies = [
"pin-project-lite",
]
[[package]]
name = "extended"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "af9673d8203fcb076b19dfd17e38b3d4ae9f44959416ea532ce72415a6020365"
[[package]]
name = "fallible-iterator"
version = "0.3.0"
@@ -3043,9 +3121,22 @@ checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
dependencies = [
"bytemuck",
"byteorder-lite",
"image-webp",
"moxcms",
"num-traits",
"png 0.18.1",
"zune-core",
"zune-jpeg",
]
[[package]]
name = "image-webp"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "525e9ff3e1a4be2fbea1fdf0e98686a6d98b4d8f937e1bf7402245af1909e8c3"
dependencies = [
"byteorder-lite",
"quick-error",
]
[[package]]
@@ -3866,6 +3957,12 @@ dependencies = [
"uuid",
]
[[package]]
name = "mach2"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dae608c151f68243f2b000364e1f7b186d9c29845f7d2d85bd31b9ad77ad552b"
[[package]]
name = "markup5ever"
version = "0.38.0"
@@ -4076,6 +4173,12 @@ dependencies = [
"thiserror 1.0.69",
]
[[package]]
name = "ndk-context"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
[[package]]
name = "ndk-sys"
version = "0.6.0+11769913"
@@ -4181,7 +4284,7 @@ version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8536030f9fea7127f841b45bb6243b27255787fb4eb83958aa1ef9d2fdc0c36"
dependencies = [
"num-complex",
"num-complex 0.2.4",
"num-integer",
"num-iter",
"num-rational",
@@ -4226,12 +4329,32 @@ dependencies = [
"num-traits",
]
[[package]]
name = "num-complex"
version = "0.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
dependencies = [
"num-traits",
]
[[package]]
name = "num-conv"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
[[package]]
name = "num-derive"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed3955f1a9c7c0c15e092f9c887db08b1fc683305fdf6eb6684f22555355e202"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.118",
]
[[package]]
name = "num-integer"
version = "0.1.47"
@@ -4317,6 +4440,32 @@ dependencies = [
"objc2-foundation",
]
[[package]]
name = "objc2-audio-toolbox"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6948501a91121d6399b79abaa33a8aa4ea7857fe019f341b8c23ad6e81b79b08"
dependencies = [
"bitflags 2.13.2",
"libc",
"objc2",
"objc2-core-audio",
"objc2-core-audio-types",
"objc2-core-foundation",
"objc2-foundation",
]
[[package]]
name = "objc2-avf-audio"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13a380031deed8e99db00065c45937da434ca987c034e13b87e4441f9e4090be"
dependencies = [
"bitflags 2.13.2",
"objc2",
"objc2-foundation",
]
[[package]]
name = "objc2-cloud-kit"
version = "0.3.2"
@@ -4328,6 +4477,29 @@ dependencies = [
"objc2-foundation",
]
[[package]]
name = "objc2-core-audio"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e1eebcea8b0dbff5f7c8504f3107c68fc061a3eb44932051c8cf8a68d969c3b2"
dependencies = [
"dispatch2",
"objc2",
"objc2-core-audio-types",
"objc2-core-foundation",
"objc2-foundation",
]
[[package]]
name = "objc2-core-audio-types"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a89f2ec274a0cf4a32642b2991e8b351a404d290da87bb6a9a9d8632490bd1c"
dependencies = [
"bitflags 2.13.2",
"objc2",
]
[[package]]
name = "objc2-core-data"
version = "0.3.2"
@@ -4345,7 +4517,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
dependencies = [
"bitflags 2.13.2",
"block2",
"dispatch2",
"libc",
"objc2",
]
@@ -5016,6 +5190,15 @@ version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
[[package]]
name = "primal-check"
version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc0d895b311e3af9902528fbb8f928688abbd95872819320517cc24ca6b2bd08"
dependencies = [
"num-integer",
]
[[package]]
name = "primefield"
version = "0.14.0"
@@ -5126,6 +5309,12 @@ dependencies = [
"winapi",
]
[[package]]
name = "quick-error"
version = "2.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
[[package]]
name = "quick-xml"
version = "0.41.0"
@@ -5423,6 +5612,12 @@ dependencies = [
"regex-syntax",
]
[[package]]
name = "regex-lite"
version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973"
[[package]]
name = "regex-syntax"
version = "0.8.11"
@@ -5438,6 +5633,7 @@ dependencies = [
"base64 0.22.1",
"bytes",
"encoding_rs",
"futures-channel",
"futures-core",
"futures-util",
"h2",
@@ -5764,6 +5960,20 @@ dependencies = [
"semver",
]
[[package]]
name = "rustfft"
version = "6.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "21db5f9893e91f41798c88680037dba611ca6674703c1a18601b01a72c8adb89"
dependencies = [
"num-complex 0.4.6",
"num-integer",
"num-traits",
"primal-check",
"strength_reduce",
"transpose",
]
[[package]]
name = "rustix"
version = "1.1.4"
@@ -6621,6 +6831,12 @@ version = "1.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
[[package]]
name = "strength_reduce"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fe895eb47f22e2ddd4dabc02bce419d2e643c8e3b585c78158b349195bc24d82"
[[package]]
name = "string_cache"
version = "0.9.0"
@@ -6668,6 +6884,192 @@ dependencies = [
"serde_json",
]
[[package]]
name = "symphonia"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a7edef6a96b696d4e0cab5ee9ebb7ca155ed95f30a6b45bbb8b97d2727f02424"
dependencies = [
"lazy_static",
"symphonia-bundle-flac",
"symphonia-bundle-mp3",
"symphonia-codec-aac",
"symphonia-codec-adpcm",
"symphonia-codec-alac",
"symphonia-codec-pcm",
"symphonia-codec-vorbis",
"symphonia-core",
"symphonia-format-isomp4",
"symphonia-format-mkv",
"symphonia-format-ogg",
"symphonia-format-riff",
"symphonia-metadata",
]
[[package]]
name = "symphonia-bundle-flac"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6405d5c34ff6f8f7ca08a4101efe66d21e180f7322ef9359900a0e55698a7892"
dependencies = [
"log",
"symphonia-common",
"symphonia-core",
"symphonia-metadata",
]
[[package]]
name = "symphonia-bundle-mp3"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "98ea5ffc8716bff677dfb3b01b420c7b758de901a72b8c330bf2040ab74b4add"
dependencies = [
"lazy_static",
"log",
"symphonia-core",
]
[[package]]
name = "symphonia-codec-aac"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f5bf8e39552d34a3c4c98333370e62f48c92456d2e814f273b5c3ad7c4a5f45c"
dependencies = [
"lazy_static",
"log",
"symphonia-common",
"symphonia-core",
]
[[package]]
name = "symphonia-codec-adpcm"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "445932ecb0c59362fde9c082dd63a75380650c5077fdb8b80b8cac850442a74c"
dependencies = [
"log",
"symphonia-core",
]
[[package]]
name = "symphonia-codec-alac"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "920a78f96f3cf62932d0c497959c0cc2100ef36b03c7ca1417b260f432a482d8"
dependencies = [
"log",
"symphonia-common",
"symphonia-core",
]
[[package]]
name = "symphonia-codec-pcm"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e04ba75686acbe43542fdd374571195f0530c0b7785ca25cc6840e9c6c4b6eea"
dependencies = [
"log",
"symphonia-core",
]
[[package]]
name = "symphonia-codec-vorbis"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "73d90b4fcf796137cc683c538282804ff9629f8ad9dbfd881fcbba331ac4e986"
dependencies = [
"log",
"symphonia-common",
"symphonia-core",
]
[[package]]
name = "symphonia-common"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2acc3fcc18ec9b8cdd48614e259c4cf0d27b71d41e5d9b120b42c5adab12d7c4"
dependencies = [
"log",
"symphonia-core",
"symphonia-metadata",
]
[[package]]
name = "symphonia-core"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "01c412864d599d4750d0c3d684d7e093ec05e5309681ef5252cc1096a437f6e0"
dependencies = [
"bitflags 2.13.2",
"bytemuck",
"lazy_static",
"log",
"num-complex 0.4.6",
"rustfft",
"smallvec",
]
[[package]]
name = "symphonia-format-isomp4"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0e681a70e1870d34e02abf1dbc51e4267c3f1827801474e8870be8c689fc4dc3"
dependencies = [
"log",
"symphonia-common",
"symphonia-core",
"symphonia-metadata",
]
[[package]]
name = "symphonia-format-mkv"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d015c5c0558864665894b3f4cbd95e10abb01b9c868e751c72670f326a56360e"
dependencies = [
"lazy_static",
"log",
"symphonia-common",
"symphonia-core",
]
[[package]]
name = "symphonia-format-ogg"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b5495e7f7e3c7035328d82b6d6e377eef289bb0c4105bdeb557fc93a833f994"
dependencies = [
"log",
"symphonia-common",
"symphonia-core",
"symphonia-metadata",
]
[[package]]
name = "symphonia-format-riff"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ff70929083a8c1a5f6cd7c904b6071c7914ad04739b510c2f7239dfc9b7dabe"
dependencies = [
"extended",
"log",
"symphonia-core",
"symphonia-metadata",
]
[[package]]
name = "symphonia-metadata"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "83713a97705d77bdef7cdbc0768fd6e5a54e4cd7e48d60a806ae85639e2c87c6"
dependencies = [
"lazy_static",
"log",
"regex-lite",
"smallvec",
"symphonia-core",
]
[[package]]
name = "syn"
version = "1.0.109"
@@ -7241,7 +7643,7 @@ dependencies = [
[[package]]
name = "thing"
version = "26.9.3"
version = "26.9.4"
dependencies = [
"aes 0.8.4",
"async-trait",
@@ -7250,6 +7652,7 @@ dependencies = [
"bytes",
"cbc 0.1.2",
"chrono",
"cpal",
"dashmap",
"dirs 5.0.1",
"encoding_rs",
@@ -7277,6 +7680,7 @@ dependencies = [
"specta",
"specta-typescript",
"ssh-key",
"symphonia",
"sysinfo",
"tauri",
"tauri-build",
@@ -7688,6 +8092,16 @@ dependencies = [
"once_cell",
]
[[package]]
name = "transpose"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ad61aed86bc3faea4300c7aee358b4c6d0c8d6ccc36524c96e4c92ccf26e77e"
dependencies = [
"num-integer",
"strength_reduce",
]
[[package]]
name = "tray-icon"
version = "0.24.1"
@@ -9263,6 +9677,21 @@ dependencies = [
"pkg-config",
]
[[package]]
name = "zune-core"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d56377fd46368984a170bc5aac5567e52ca5da874caa60bea39fcbca78fb658b"
[[package]]
name = "zune-jpeg"
version = "0.5.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"
dependencies = [
"zune-core",
]
[[package]]
name = "zvariant"
version = "5.13.0"
+26 -3
View File
@@ -1,6 +1,6 @@
[package]
name = "thing"
version = "26.9.3"
version = "26.9.4"
description = "A Tauri App"
authors = ["you"]
edition = "2021"
@@ -35,7 +35,10 @@ specta = { version = "=2.0.0-rc.25", features = ["derive", "function", "serde_js
specta-typescript = "0.0.12"
tauri-specta = { version = "=2.0.0-rc.25", features = ["typescript"] }
chrono = "0.4"
reqwest = { version = "0.12", features = ["json", "stream", "multipart"] }
# blocking:音乐播放引擎在**独立 std 线程**上解码(symphonia 的 MediaSource 是同步
# Read+Seek),需要同步 HTTP 客户端去按 Range 拉 NAS 音频流。放在 std 线程上用
# blocking 是安全的(在 tokio 运行时线程里用才会 panic)。
reqwest = { version = "0.12", features = ["json", "stream", "multipart", "blocking"] }
futures-util = "0.3"
tokio = { version = "1", features = ["io-util", "time", "rt-multi-thread", "macros", "sync", "fs", "net"] }
axum = "0.7"
@@ -98,12 +101,22 @@ cbc = "0.1"
rsa = { version = "0.9", features = ["pem"] }
rand = "0.8"
tokio-tungstenite = "0.24"
image = { version = "0.25", default-features = false, features = ["png"] }
image = { version = "0.25", default-features = false, features = ["png", "jpeg", "webp"] }
walkdir = "2"
notify = { version = "6", features = [] }
librqbit = "9"
bytes = "1"
windows-capture = "2.0.1"
# 音频解码(纯 Rust)。**默认特性不含 mp3/aac/alac/isomp4**——0.6 起这几项被移出
# default,必须显式打开,否则 mp3 与 m4a 直接报「不支持的格式」。
# default 已含:flac / wav / ogg / vorbis / pcm / adpcm / mkv + 全部元数据。
# 注意:`ape` 只是**元数据**特性(symphonia-metadata/ape),没有 APE 解码器;
# 也没有 opus 特性(ogg 里若是 Opus 轨道无法解码)。这两点已与用户确认接受。
symphonia = { version = "0.6", features = ["mp3", "aac", "alac", "isomp4"] }
# 音频输出。Windows 走 WASAPI:cpal 的共享模式输出带
# AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM | SRC_DEFAULT_QUALITY,因此**可以用源采样率
# 直接建流**,由 Windows 自己转换到设备混音格式 —— 不需要额外引入重采样库。
cpal = "0.18"
# HDR 截图说明:windows-capture 的 Windows Graphics Capture 后端在 HDR 显示器上
# 可能输出 scRGB / rgba16F 或 HDR10(PQ) 格式的帧,与项目其余截图路径
# (GDI BitBlt,sRGB 8bit)色彩空间不一致。capture 层统一转成 sRGB 8bit
@@ -159,9 +172,19 @@ windows = { version = "0.52", features = [
"Globalization",
"Graphics_Imaging",
"Media_Ocr",
# 音乐模块:系统媒体传输控件(SMTC)。Windows.Media 提供
# SystemMediaTransportControls / DisplayUpdater / MusicDisplayProperties /
# TimelineProperties;Win32_System_WinRT 提供桌面应用唯一的取用入口
# ISystemMediaTransportControlsInterop::GetForWindow。
# 之所以不用前端 navigator.mediaSession 当唯一通道:WebView2 只转发标题/歌手/进度,
# 专辑与封面不送达,且会话挂在浏览器进程 AUMID 上只显示「未知应用」。
"Media",
"Win32_System_WinRT",
"Security_Cryptography",
# 划词取词的智能路径:UIA 直读焦点元素选区(IUIAutomation / ITextProvider)
"Win32_UI_Accessibility",
# OCR:CryptographicBuffer / SoftwareBitmap::CreateCopyFromBuffer 的 IBuffer 属于
# Windows.Storage.Streams,缺这个 feature 会 E0599 找不到 CreateFromByteArray
"Storage_Streams",
# HDR 探测:DXGI 的 advanced color 查询用于判断显示器是否处于 HDR / WCG 状态,
# 并读取其色域与传递函数(G2084/PQ 表示 HDR10)。截图前据此决定是否做色调映射。
@@ -379,21 +379,95 @@ async function shouldIntercept(downloadItem) {
}
/**
* 判断是否为"历史下载"(安装插件之前就已存在、随后被浏览器恢复的旧下载)
* 判断是否为"历史下载"(本次浏览器会话开始之前就存在、浏览器重启/恢复后才重新触发的下载)
* 这类下载一律不接管,交给浏览器原生处理,实现"只接管以后的下载,历史都不管"
*
* 三重判据(任一命中即视为历史下载):
* 1. canResume=true:已存在有效的部分文件,说明浏览器在恢复旧下载
* 2. 开始时间早于插件首次安装时间
* 3. 开始时间早于**本次浏览器会话**起点:浏览器重启时会恢复上次未完成的下载,
* 这些下载的 startTime 仍是上次会话的时间,因此一定会落在会话起点之前。
* (只靠 1/2 不够:上次会话启动的下载若被浏览器重新排队,canResume 可能为 false,
* 而 startTime 又晚于安装时间 —— 这正是"关掉浏览器后莫名多出历史下载"的成因)
*/
async function isHistoricalDownload(item) {
// 1) canResume=true 表示已存在有效的部分文件,说明浏览器在恢复旧下载
if (item.canResume) return true
const start = item.startTime ? new Date(item.startTime).getTime() : 0
// 2) 开始时间早于插件首次安装时间(浏览器重启后恢复的旧下载会保留原来的开始时间)
try {
const start = item.startTime ? new Date(item.startTime).getTime() : 0
if (start > 0) {
const stored = await chrome.storage.local.get('installTime')
const installTime = stored.installTime || 0
if (installTime > 0 && start < installTime) return true
const stored = await chrome.storage.local.get('installTime')
const installTime = stored.installTime || 0
if (installTime > 0 && start > 0 && start < installTime) return true
} catch { /* ignore */ }
// 3) 开始时间早于本次浏览器会话起点(含 5s 宽限,避免刚启动时误判新下载)
const sessionStart = await ensureSessionStart()
if (start > 0 && start < sessionStart - RESTORE_GRACE_MS) return true
return false
}
/** 浏览器会话起点(chrome.storage.session 在浏览器关闭后自动清空) */
const SESSION_START_KEY = 'sessionStart'
/** 会话起点宽限:会话刚建立时新下载的 startTime 可能略早于起点记录时刻 */
const RESTORE_GRACE_MS = 5000
let sessionStartCache = 0
/**
* 取本次浏览器会话的起点时间戳(首次调用时写入 storage.session)。
* 用 storage.session 而非 storage.local 的原因:它随浏览器关闭而清空,
* "存在"本身就等价于"本次会话已开始",无需自己判断重启。
*/
async function ensureSessionStart() {
if (sessionStartCache) return sessionStartCache
try {
const s = await chrome.storage.session.get(SESSION_START_KEY)
if (s[SESSION_START_KEY]) {
sessionStartCache = s[SESSION_START_KEY]
return sessionStartCache
}
} catch { /* ignore */ }
sessionStartCache = Date.now()
try {
await chrome.storage.session.set({ [SESSION_START_KEY]: sessionStartCache })
} catch { /* ignore */ }
return sessionStartCache
}
/** 已处理过的下载 guid(持久化,浏览器重启后仍能认出同一条下载) */
const SEEN_GUIDS_KEY = 'seenDownloadGuids'
/** 记录上限:只用于识别"同一条下载被重复通知",不需要长期留存 */
const SEEN_GUIDS_MAX = 300
let seenGuidsCache = null
async function loadSeenGuids() {
if (seenGuidsCache) return seenGuidsCache
try {
const s = await chrome.storage.local.get(SEEN_GUIDS_KEY)
seenGuidsCache = Array.isArray(s[SEEN_GUIDS_KEY]) ? s[SEEN_GUIDS_KEY] : []
} catch {
seenGuidsCache = []
}
return seenGuidsCache
}
/**
* 记录 guid 并返回它此前是否已见过。
* `true` 表示这条下载我们处理过/见过,本次是重复通知(浏览器恢复旧下载时会复用原 guid),
* 必须跳过,否则会把历史下载重新丢进 Thing。
*/
async function markGuidSeen(guid) {
const seen = await loadSeenGuids()
if (seen.includes(guid)) return true
seen.push(guid)
if (seen.length > SEEN_GUIDS_MAX) seen.splice(0, seen.length - SEEN_GUIDS_MAX)
seenGuidsCache = seen
try {
await chrome.storage.local.set({ [SEEN_GUIDS_KEY]: seen })
} catch { /* ignore */ }
return false
}
@@ -417,6 +491,10 @@ async function hasExistingTask(url) {
async function handleDownloadCreated(downloadItem) {
const url = downloadItem.finalUrl || downloadItem.url
// 同一条下载只处理一次:浏览器重启后恢复的旧下载会带着原 guid 再次触发 onCreated,
// 不拦下来就会把「早已看过/已完成」的下载重新丢进 Thing(表现为莫名弹出历史下载)
if (downloadItem.guid && await markGuidSeen(downloadItem.guid)) return
// 回退下载:我们自己用 chrome.downloads.download 创建的,直接跳过,避免无限循环
const fbExp = fallbackUrls.get(url)
if (fbExp && Date.now() < fbExp) {
@@ -1,7 +1,7 @@
{
"manifest_version": 3,
"name": "Thing Extension",
"version": "0.30",
"version": "0.31",
"description": "发送浏览器下载到 Thing 下载引擎,嗅探网页资源。",
"icons": {
"16": "icons/icon-16.png",
+4
View File
@@ -102,6 +102,10 @@ pub mod events {
pub const TERMINAL_SETTINGS: &str = "terminal-settings";
// 音乐模块:下载任务事件(桥接事件行 → 前端,负载见 bridge.py _emit_event)
pub const MUSIC_DOWNLOAD_EVENT: &str = "music-download-event";
// 音乐模块:Rust 侧播放引擎(music/audio)。曲目自然播完(缓冲也放完)后发出,无负载
pub const MUSIC_AUDIO_ENDED: &str = "music-audio-ended";
/// 音乐模块:Rust 侧播放失败(音源打不开 / 解码失败 / 输出设备异常),负载为错误文本
pub const MUSIC_AUDIO_ERROR: &str = "music-audio-error";
// 后端自动切换节点完成(前端据以刷新节点列表并提示)
pub const PROXY_AUTO_SWITCH: &str = "proxy-auto-switch";
// 应用更新进度
+23 -7
View File
@@ -235,7 +235,12 @@ impl DownloadEngine {
let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst);
self.ensure_mihomo_proxy().await;
let probe = self.inner.http.probe(url, headers, use_proxy).await;
// 交互式校验(「添加下载」对话框):用户在等结果,保留探测超时避免界面卡死
let probe = self
.inner
.http
.probe(url, headers, use_proxy, Some(super::http_dl::PROBE_TIMEOUT))
.await;
let settings = self.inner.settings.lock().unwrap_or_else(|e| e.into_inner()).clone();
let task_dir = dir.map(|d| d.to_string()).unwrap_or_else(|| settings.download_dir.clone());
@@ -390,13 +395,17 @@ impl DownloadEngine {
/// 生成不冲突的文件名(同名时追加 (1)、(2)...)
/// 冲突来源:磁盘已有同名最终文件、已存在同名临时文件(其他任务正在下载该名)、
/// 以及任务列表中已有任务占用同名(即使最终文件尚未落盘,避免共用同一 .thingdl 临时文件)
fn generate_unique_filename(&self, dir: &str, filename: &str) -> String {
///
/// `exclude_id`:把某个任务排除在「已占用」之外。探测完成后用真实文件名重命名时
/// 必须传自己的 id —— 否则会与**自己**的占位文件名相撞,把每一个下载都改名成
/// `xxx (1).ext`(探测文件名与 URL 推导名一致时必现)。
fn generate_unique_filename(&self, dir: &str, filename: &str, exclude_id: Option<&str>) -> String {
// 任务列表中已占用的文件名(同一目录下)
let taken: std::collections::HashSet<String> = {
let tasks = self.inner.tasks.lock().unwrap_or_else(|e| e.into_inner());
tasks
.values()
.filter(|t| t.dir == dir)
.filter(|t| t.dir == dir && Some(t.id.as_str()) != exclude_id)
.map(|t| t.filename.clone())
.collect()
};
@@ -487,7 +496,7 @@ impl DownloadEngine {
.unwrap_or_else(|| format!("download_{}", chrono::Utc::now().timestamp()))
});
if auto_rename {
task_filename = self.generate_unique_filename(&task_dir, &task_filename);
task_filename = self.generate_unique_filename(&task_dir, &task_filename, None);
}
// 3) 立即插入占位任务:Queued(未探测完成前 schedule 会跳过),未知大小单段
@@ -536,7 +545,13 @@ impl DownloadEngine {
let use_proxy = self.inner.use_proxy.load(Ordering::SeqCst);
tauri::async_runtime::spawn(async move {
engine.ensure_mihomo_proxy().await;
let probe = engine.inner.http.probe(&raw_url, &raw_headers, use_proxy).await;
// 后台探测不设超时:服务器慢就继续等(与下载路径一致),
// 只有真正失败才置 Error;用户暂停/取消走任务的取消标志。
let probe = engine
.inner
.http
.probe(&raw_url, &raw_headers, use_proxy, None)
.await;
// 探测结束,解除 pending 门控
engine
@@ -591,10 +606,11 @@ impl DownloadEngine {
}
};
// 释放 tasks 锁后,若探测返回了真实文件名,重新做唯一化并写回
// 释放 tasks 锁后,若探测返回了真实文件名,重新做唯一化并写回。
// 必须排除自己(`&rid`):占位名往往与探测名相同,不排除就会和自己相撞而改名成 (1)
if let Some((dir_owned, Some(real_name))) = rename_from {
let final_name = if auto_rename {
engine.generate_unique_filename(&dir_owned, &real_name)
engine.generate_unique_filename(&dir_owned, &real_name, Some(&rid))
} else {
real_name
};
+109 -58
View File
@@ -13,11 +13,49 @@ use tokio::task::JoinSet;
use super::rate_limit::RateLimiter;
use super::task::{ProbeResult, Segment};
/// 请求超时:连接 + 响应头必须在 30s 内就绪(分段请求若无超时,
/// 服务器挂死时任务将永久卡在 Active,pause→resume 会出现新旧任务并发写同一临时文件)
const REQUEST_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
/// 分块读取停滞超时:30s 内无任何数据视为连接挂死,主动中断(配合取消标志及时退出)
const READ_STALL_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
/// 取消轮询间隔。
///
/// **这不是下载超时**:下载路径不再因「长时间无数据/无响应头」中断,服务器慢就继续等,
/// 只有用户暂停/取消或真正报错才结束。这个 200ms 轮询的唯一作用是让暂停/取消在
/// 「连接挂死、`stream.next()` 一直 pending」时也能及时被感知——
/// 否则等待 future 永不返回,取消标志就永远读不到。
const CANCEL_POLL_INTERVAL: std::time::Duration = std::time::Duration::from_millis(200);
/// 交互式探测超时(仅用于「添加下载」校验等用户正盯着界面等结果的场景:
/// 无限等待等于界面卡死)。真正的下载/后台探测路径不设超时。
pub const PROBE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
/// 等待一个 future 完成,期间每 200ms 检查一次取消标志;**不设超时**。
///
/// 返回 `Err("已取消")` 表示用户暂停/取消(调用方据此把任务置为 Paused 而非 Error)。
async fn wait_cancellable<F>(fut: F, cancel: &AtomicBool) -> Result<F::Output, String>
where
F: std::future::Future,
{
tokio::pin!(fut);
loop {
if cancel.load(Ordering::SeqCst) {
return Err("已取消".to_string());
}
tokio::select! {
biased;
_ = tokio::time::sleep(CANCEL_POLL_INTERVAL) => continue,
out = &mut fut => return Ok(out),
}
}
}
/// 按需给「发送请求」加超时:`None` 表示不设超时(服务器慢就继续等)。
/// `Err(())` 只表示超时,这样调用方能把它与「请求失败」区分开(后者要回退 HEAD)。
async fn send_with_optional_timeout(
req: reqwest::RequestBuilder,
timeout: Option<std::time::Duration>,
) -> Result<reqwest::Result<reqwest::Response>, ()> {
match timeout {
Some(d) => tokio::time::timeout(d, req.send()).await.map_err(|_| ()),
None => Ok(req.send().await),
}
}
/// HTTP/HTTPS 下载器
#[derive(Clone)]
@@ -97,19 +135,23 @@ impl HttpDownloader {
/// 探测下载资源信息(大小、是否支持 Range、文件名)
/// 优先用 GET + Range: bytes=0-0(返回 206 + Content-Range),回退到 HEAD。
/// 代理降级:use_proxy=true 时先走系统代理,失败则回退 no_proxy 直连重试一次
/// 代理降级:use_proxy=true 时先走系统代理,失败则回退 no_proxy 直连重试一次。
///
/// `timeout`:`Some` 用于交互式探测(用户正等界面结果);`None` 表示不设超时
/// (后台探测,如更新包下载,服务器慢就继续等)。
pub async fn probe(
&self,
url: &str,
headers: &HashMap<String, String>,
use_proxy: bool,
timeout: Option<std::time::Duration>,
) -> Result<ProbeResult, String> {
let first = self.client(use_proxy);
match self.probe_with_client(&first, url, headers).await {
match self.probe_with_client(&first, url, headers, timeout).await {
Ok(r) => return Ok(r),
Err(e) if use_proxy => {
let direct = self.client(false);
self.probe_with_client(&direct, url, headers)
self.probe_with_client(&direct, url, headers, timeout)
.await
.map_err(|e2| format!("代理探测失败({}),直连重试也失败({})", e, e2))
}
@@ -123,6 +165,7 @@ impl HttpDownloader {
client: &Client,
url: &str,
headers: &HashMap<String, String>,
timeout: Option<std::time::Duration>,
) -> Result<ProbeResult, String> {
// 先尝试 Range 请求(能同时判断 Accept-Ranges 和获取大小)
let mut req = client
@@ -133,10 +176,14 @@ impl HttpDownloader {
req = req.header(k, v);
}
match tokio::time::timeout(REQUEST_TIMEOUT, req.send())
.await
.map_err(|_| "探测超时(30s 内未收到响应头)".to_string())?
{
// 先拿到「发送结果」:超时(仅交互式探测会有)直接上抛,
// 发送失败则回退 HEAD。注意不能把发送失败也上抛——那会让 HEAD 回退失效。
let first = match send_with_optional_timeout(req, timeout).await {
Err(()) => return Err("探测超时(未收到响应头)".to_string()),
Ok(r) => r,
};
match first {
Ok(resp) => {
let status = resp.status();
let headers_map = resp.headers().clone();
@@ -185,9 +232,9 @@ impl HttpDownloader {
for (k, v) in headers {
head_req = head_req.header(k, v);
}
let resp = tokio::time::timeout(REQUEST_TIMEOUT, head_req.send())
let resp = send_with_optional_timeout(head_req, timeout)
.await
.map_err(|_| "探测超时(HEAD 30s 内未收到响应头)".to_string())?
.map_err(|_| "探测超时(HEAD 未收到响应头)".to_string())?
.map_err(|e| format!("探测失败(GET 和 HEAD 均失败): {}", e))?;
let headers_map = resp.headers().clone();
let total_size = headers_map
@@ -421,9 +468,10 @@ async fn download_segment_with_client(
req = req.header(k, v);
}
let resp = tokio::time::timeout(REQUEST_TIMEOUT, req.send())
.await
.map_err(|_| "请求超时(30s 内未收到响应头)".to_string())?
// 等响应头:不设超时(服务器慢就继续等),但期间轮询取消标志,
// 保证用户暂停/取消时能立刻中断这次请求。
let resp = wait_cancellable(req.send(), &cancel)
.await?
.map_err(|e| format!("请求失败: {}", e))?;
let status = resp.status();
@@ -453,50 +501,53 @@ async fn download_segment_with_client(
return Err("已取消".to_string());
}
// 停滞超时:30s 无数据即中断,确保 cancel 标志能及时被感知(配合代际句柄防并发写)
match tokio::time::timeout(READ_STALL_TIMEOUT, stream.next()).await {
Ok(Some(Ok(chunk))) => {
buf.extend_from_slice(&chunk);
// 接收到数据立即更新进度(避免监控周期内进度无变化导致速度显示为 0)
local_completed += chunk.len() as u64;
progress.store(local_completed, Ordering::Relaxed);
// 积累到 64KB 再写入(减少 I/O 次数)
if buf.len() >= 64 * 1024 {
file.write_all(&buf)
.await
.map_err(|e| format!("写入文件失败: {}", e))?;
// 限速
limiter.consume(buf.len() as u64).await;
buf.clear();
// 读数据:**不做停滞超时**——30s 无数据不代表失败(慢速源、网络抖动很常见),
// 只要用户没暂停就继续等。select 里那个 200ms 计时器只负责周期性回到循环头
// 读一次取消标志:否则 `stream.next()` 一直 pending 时暂停/取消永远感知不到。
tokio::select! {
biased;
_ = tokio::time::sleep(CANCEL_POLL_INTERVAL) => continue,
next = stream.next() => match next {
Some(Ok(chunk)) => {
buf.extend_from_slice(&chunk);
// 接收到数据立即更新进度(避免监控周期内进度无变化导致速度显示为 0)
local_completed += chunk.len() as u64;
progress.store(local_completed, Ordering::Relaxed);
// 积累到 64KB 再写入(减少 I/O 次数)
if buf.len() >= 64 * 1024 {
file.write_all(&buf)
.await
.map_err(|e| format!("写入文件失败: {}", e))?;
// 限速
limiter.consume(buf.len() as u64).await;
buf.clear();
}
}
}
Ok(Some(Err(e))) => {
return Err(format!("读取数据失败: {}", e));
}
Ok(None) => {
// 流结束,写入剩余数据
if !buf.is_empty() {
file.write_all(&buf)
.await
.map_err(|e| format!("写入文件失败: {}", e))?;
// local_completed 和 progress 已在接收 chunk 时更新
limiter.consume(buf.len() as u64).await;
buf.clear();
Some(Err(e)) => {
return Err(format!("读取数据失败: {}", e));
}
// 校验:已知大小的分段若流提前结束(收到的字节数不足分段长度),
// 说明服务器提前断开或返回不完整内容,不能标记为完成,否则文件会被截断
if !unknown_size && local_completed < seg.len() {
return Err(format!(
"文件不完整:已接收 {} / {} 字节,服务器提前结束连接",
local_completed,
seg.len()
));
None => {
// 流结束,写入剩余数据
if !buf.is_empty() {
file.write_all(&buf)
.await
.map_err(|e| format!("写入文件失败: {}", e))?;
// local_completed 和 progress 已在接收 chunk 时更新
limiter.consume(buf.len() as u64).await;
buf.clear();
}
// 校验:已知大小的分段若流提前结束(收到的字节数不足分段长度),
// 说明服务器提前断开或返回不完整内容,不能标记为完成,否则文件会被截断
if !unknown_size && local_completed < seg.len() {
return Err(format!(
"文件不完整:已接收 {} / {} 字节,服务器提前结束连接",
local_completed,
seg.len()
));
}
break;
}
break;
}
Err(_) => {
return Err("读取超时(30s 无数据,已中断下载)".to_string());
}
},
}
}
+42 -1
View File
@@ -51,12 +51,16 @@ use music::{
feiniu_list_connections, feiniu_list_audio_files, feiniu_list_tracks, feiniu_login,
feiniu_logout, feiniu_lyric,
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_state, music_audio_stop,
music_cancel_runtime_install, music_download, music_download_cancel, music_env_status,
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_smtc_clear, music_smtc_update_metadata, music_smtc_update_playback_state,
music_smtc_update_position,
music_stop_bridge, music_update_musicdl, webdav_delete, webdav_get_secret,
webdav_save_secret, webdav_test,
webdav_upload, MusicManager,
webdav_upload, AudioEngine, MusicManager, SmtcController,
};
use network_monitor::network_status;
use osd_window::{
@@ -226,6 +230,9 @@ fn export_bindings() {
// music(6,豁免 3:music_ping / music_get_sources / music_search 返回 serde_json::Value)
music_env_status, music_install_runtime, music_cancel_runtime_install,
music_stop_bridge, music_get_settings, music_save_settings,
// music 播放引擎(Rust 侧播放,取代前端 <audio>)
music_audio_play, music_audio_set_playing, music_audio_seek, music_audio_stop,
music_audio_set_volume, music_audio_state,
// screenshot(23,豁免 3:get_fullscreen_bmp / take_editor_image_raw 返回 ipc::Response、
// compose_copy / compose_png 接收 ipc::Request)
screenshot_disable_transitions, screenshot_show_overlay, screenshot_register_shortcut,
@@ -287,6 +294,14 @@ pub fn run() {
#[cfg(debug_assertions)]
export_bindings();
// 必须在创建任何窗口之前:让系统按 AUMID 认出本应用(系统媒体面板/任务栏据此显示
// 应用名与图标,否则只显示「未知应用」)。取值与安装包写进开始菜单快捷方式的
// AppUserModelID 一致,即 Tauri 的 identifier。
// (Chromium 自带媒体会话的压制:环境变量与 additionalBrowserArgs 两条路都已实测
// 不可用,详见 music/smtc.rs 的模块注释。)
#[cfg(windows)]
win32_util::set_app_user_model_id("thing.lfeng.me");
tauri::Builder::default()
.plugin(tauri_plugin_autostart::Builder::new().build())
.plugin(tauri_plugin_opener::init())
@@ -302,6 +317,9 @@ pub fn run() {
)
.manage(ProcessManager::new())
.manage(ThinghkUpdateState::new())
.manage(SmtcController::new())
// Rust 侧播放引擎(取代前端 <audio>,见 music/audio 模块注释)
.manage(AudioEngine::new())
.invoke_handler(tauri::generate_handler![
quit_app,
app_version,
@@ -391,6 +409,16 @@ pub fn run() {
feiniu_cache_clear,
feiniu_cache_fetch,
feiniu_fnconnect_resolve,
music_smtc_update_metadata,
music_smtc_update_position,
music_smtc_update_playback_state,
music_smtc_clear,
music_audio_play,
music_audio_set_playing,
music_audio_seek,
music_audio_stop,
music_audio_set_volume,
music_audio_state,
webdav_test,
webdav_upload,
webdav_delete,
@@ -638,6 +666,19 @@ pub fn run() {
terminal_ai_suggest
])
.setup(setup::init)
// 启动耗时定位:main 窗口的「页面加载完成」单独留痕。
// 它是「WebView2 拉取页面」与「前端模块图执行」之间的分界——后者的终点是
// 前端的 `[main] Thing 应用启动`。两者谁慢,看这两条日志的间隔即可。
.on_page_load(|webview, payload| {
let phase = match payload.event() {
tauri::webview::PageLoadEvent::Started => "开始",
tauri::webview::PageLoadEvent::Finished => "完成",
};
crate::logger::log_info(
"boot",
&format!("页面加载{}: {} ({})", phase, payload.url(), webview.label()),
);
})
.on_window_event(|window, event| {
// 仅主窗口拦截关闭(隐藏到托盘)。其他窗口(截图编辑器/OSD 等)
// 调用 close() 是真实销毁语义,全局拦截会导致隐藏窗口累积泄漏。
+9
View File
@@ -2,5 +2,14 @@
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
fn main() {
// WebView2 的浏览器参数这里不设置。
//
// 为关掉 Chromium 自带媒体会话(SMTC)而注入浏览器参数的两条路都已实测不可用,
// 详见 music/smtc.rs 的模块注释:
// 1) `WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS` 环境变量——本应用支持永久提权,
// 而提权进程下 WebView2 会忽略所有 WEBVIEW2_* 变量(微软文档明确说明);
// 2) tauri.conf.json 的 `additionalBrowserArgs`——参数只加在主窗口上,与其余弹窗
// 的参数不一致却共用同一个 EBWebView 用户数据目录,结果是托盘菜单/截图等窗口
// 的页面永远不执行 JS,彻底唤不出。
thing_lib::run()
}
+496
View File
@@ -0,0 +1,496 @@
//! Rust 侧音频播放引擎:解码 + 输出都在后端完成,前端只发命令、读状态。
//!
//! # 为什么要搬到 Rust(而不是继续用前端 `<audio>`)
//!
//! 前端播放时,Chromium 会为播放中的媒体元素自动注册一条系统媒体会话(SMTC),
//! 与 [`super::smtc`] 投递的原生会话并行 → Windows 媒体面板出现两条「媒体」。
//! 能关掉它的浏览器参数(`--disable-features=MediaSessionService`)会把本应用的
//! 其他 WebView 窗口一起弄死(见 smtc 模块注释),前端 `navigator.mediaSession`
//! 空桩又拦不住浏览器侧的注册。**主窗口只要不再持有 `<audio>`,就没有会话可注册**,
//! 于是不需要任何浏览器参数,其他窗口也恢复原状。
//!
//! # 线程模型
//!
//! - **调用方线程**(Tauri 命令):只做控制(play / pause / seek / stop / 音量)与状态查询,
//! 全部是原子操作或往通道发一条消息,绝不等待。
//! - **播放线程**(每个会话一条 std 线程):打开音源、探测格式、建输出流、解码填缓冲。
//! `cpal::Stream` 不是 `Send`,必须由它自己创建并持有,因此它随会话生灭。
//! - **音频回调线程**(cpal 内部):只做「出队 → 乘增益 → 转格式」,见 [`super::output`]。
//!
//! # 会话隔离
//!
//! [`Shared`] 是**每个会话一份**的:切歌时先把旧会话静音(立刻生效),再建新会话。
//! 若共用一份共享状态,旧线程还在写、新线程已经在读,会出现「两首歌混在一起」。
//!
//! # 暂停/定位的实现取舍
//!
//! 暂停**不清空缓冲**、也不停输出流,只让回调输出静音(见 output::fill):这样恢复播放
//! 是瞬时的,且不会因为反复启停声卡产生爆音。
//! 定位则清空缓冲并让解码器重新定位,位置计数同步跳到目标点。
use std::collections::VecDeque;
use std::sync::atomic::{AtomicBool, AtomicU16, AtomicU32, AtomicU64, Ordering};
use std::sync::mpsc::{self, Receiver, Sender, TryRecvError};
use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
use std::time::Duration;
use serde::Serialize;
use specta::Type;
use symphonia::core::codecs::audio::AudioDecoderOptions;
use symphonia::core::errors::Error as SymphoniaError;
use symphonia::core::formats::{FormatOptions, FormatReader, SeekMode, SeekTo, TrackType};
use symphonia::core::formats::probe::Hint;
use symphonia::core::io::MediaSourceStream;
use symphonia::core::meta::MetadataOptions;
use symphonia::core::units::Time;
use tauri::{AppHandle, Emitter};
use super::{output, source};
/// 播放缓冲上限(秒)。
///
/// 太小:解码抖动(网络流尤其)会来不及补数据 → 断音;
/// 太大:定位时要丢弃更多已解码数据,拖进度条的反应变慢。2 秒是这两者间的常见折中。
const BUFFER_SECONDS: f64 = 2.0;
/// 栈上临时帧数组的容量上限(源声道数超过它时多出的声道被忽略)。
const MAX_CHANNELS: usize = 8;
/// 单个会话的共享状态:解码线程写、音频回调读写、命令线程只读写原子量。
pub(crate) struct Shared {
/// 交错 f32 样本队列(生产 = 解码线程,消费 = 音频回调)
pub buf: Mutex<VecDeque<f32>>,
/// 已播放帧数:**播放位置以它为准**(只有音频回调会自增,定位时由解码线程重置)
pub frames_played: AtomicU64,
/// 源采样率(Hz)
pub rate: AtomicU32,
/// 源声道数
pub src_channels: AtomicU16,
/// 设备输出声道数([`output::build`] 写入)
pub out_channels: AtomicU16,
/// 是否处于播放态(false = 回调输出静音且不消费队列)
pub playing: AtomicBool,
pub muted: AtomicBool,
/// 目标音量(f32 的位表示)
pub volume: AtomicU32,
/// 当前增益(f32 的位表示;音量斜坡用,只有回调写)
pub gain: AtomicU32,
/// 已到达流末尾
pub finished: AtomicBool,
/// 输出流报错(设备被拔/被独占/驱动异常)
pub failed: AtomicBool,
}
impl Shared {
fn new(volume: f32, muted: bool) -> Self {
Self {
buf: Mutex::new(VecDeque::new()),
frames_played: AtomicU64::new(0),
rate: AtomicU32::new(0),
src_channels: AtomicU16::new(0),
out_channels: AtomicU16::new(0),
playing: AtomicBool::new(true),
muted: AtomicBool::new(muted),
volume: AtomicU32::new(volume.to_bits()),
// 起始增益等于目标音量:避免起播瞬间从 0 拉起来产生的淡入延迟
gain: AtomicU32::new(volume.to_bits()),
finished: AtomicBool::new(false),
failed: AtomicBool::new(false),
}
}
fn queue_len(&self) -> usize {
self.buf.lock().unwrap_or_else(|e| e.into_inner()).len()
}
}
/// 播放线程收到的控制消息。音量/静音/暂停走原子量,不进通道(不必串到解码线程)。
enum Control {
/// 定位到指定秒(精确定位由解码线程负责)
Seek(f64),
/// 结束会话(线程随即退出并丢弃输出流)
Stop,
}
/// 一次播放会话的句柄。
struct Session {
shared: Arc<Shared>,
ctrl: Sender<Control>,
handle: JoinHandle<()>,
}
/// 播放状态快照(返回前端)。进度用**拉取**而不是每帧推送:
/// 高频 emit 既费 IPC,又会在拖动进度条时和本地状态打架。
#[derive(Serialize, Clone, Type)]
#[serde(rename_all = "camelCase")]
pub struct AudioState {
/// 是否存在有效会话(false = 已停止/无曲目)
pub active: bool,
pub playing: bool,
/// 当前播放位置(秒)
pub position_sec: f64,
/// 已解码待播的秒数
pub buffered_sec: f64,
/// 源采样率(Hz),0 = 尚未探测出来
pub sample_rate: u32,
pub finished: bool,
pub failed: bool,
}
/// 音频引擎:持有当前会话,并保留跨曲目生效的音量/静音。
pub struct AudioEngine {
/// 用 Arc 装:命令线程要能拿到会话去改状态,而结束会话时要能把它整体摘掉
session: Mutex<Option<Arc<Session>>>,
/// 音量与静音在切歌后沿用(用户在播放器或设置里调过之后不该被重置)
volume: AtomicU32,
muted: AtomicBool,
}
impl AudioEngine {
pub fn new() -> Self {
Self {
session: Mutex::new(None),
volume: AtomicU32::new(1.0f32.to_bits()),
muted: AtomicBool::new(false),
}
}
/// 开始播放一个音源。
///
/// `spec` 为本地绝对路径或流地址([`source::open`] 按 scheme 判定);
/// `start_sec` 用于「退出时的进度」续播。旧会话会先被静音并结束。
pub fn play(&self, app: &AppHandle, spec: String, start_sec: f64) -> Result<(), String> {
self.stop_current();
let shared = Arc::new(Shared::new(
f32::from_bits(self.volume.load(Ordering::Relaxed)),
self.muted.load(Ordering::Relaxed),
));
let (ctrl_tx, ctrl_rx) = mpsc::channel();
let thread_shared = shared.clone();
let thread_app = app.clone();
let handle = thread::Builder::new()
.name("music-audio".to_string())
.spawn(move || {
if let Err(e) = run_session(&thread_shared, &ctrl_rx, &thread_app, &spec, start_sec) {
crate::logger::log_error("music-audio", &format!("播放失败({spec}): {e}"));
let _ = thread_app.emit(crate::constants::events::MUSIC_AUDIO_ERROR, e);
}
})
.map_err(|e| format!("创建播放线程失败: {e}"))?;
*self.session.lock().unwrap_or_else(|e| e.into_inner()) = Some(Arc::new(Session {
shared,
ctrl: ctrl_tx,
handle,
}));
Ok(())
}
/// 暂停/恢复。走原子量,不进通道,因此是瞬时生效的。
pub fn set_playing(&self, playing: bool) {
if let Some(s) = self.current() {
s.shared.playing.store(playing, Ordering::SeqCst);
}
}
/// 定位到指定秒。
pub fn seek(&self, sec: f64) {
if let Some(s) = self.current() {
let _ = s.ctrl.send(Control::Seek(sec));
}
}
/// 停止播放并释放设备。
pub fn stop(&self) {
self.stop_current();
}
/// 设置音量与静音。目标值立即写入(回调在本块内斜坡过去,无爆音),
/// 同时记在引擎上供下一首沿用。
pub fn set_volume(&self, volume: f32, muted: bool) {
let volume = volume.clamp(0.0, 1.0);
self.volume.store(volume.to_bits(), Ordering::Relaxed);
self.muted.store(muted, Ordering::Relaxed);
if let Some(s) = self.current() {
s.shared.volume.store(volume.to_bits(), Ordering::Relaxed);
s.shared.muted.store(muted, Ordering::Relaxed);
}
}
pub fn state(&self) -> AudioState {
let Some(s) = self.current() else {
return AudioState {
active: false,
playing: false,
position_sec: 0.0,
buffered_sec: 0.0,
sample_rate: 0,
finished: false,
failed: false,
};
};
let rate = s.shared.rate.load(Ordering::Relaxed).max(1);
let ch = s.shared.src_channels.load(Ordering::Relaxed).max(1) as usize;
let frames = s.shared.frames_played.load(Ordering::Relaxed);
let queued = s.shared.queue_len();
AudioState {
active: true,
playing: s.shared.playing.load(Ordering::Relaxed),
position_sec: frames as f64 / rate as f64,
buffered_sec: queued as f64 / (rate as f64 * ch as f64),
sample_rate: s.shared.rate.load(Ordering::Relaxed),
finished: s.shared.finished.load(Ordering::Relaxed),
failed: s.shared.failed.load(Ordering::Relaxed),
}
}
fn current(&self) -> Option<Arc<Session>> {
self.session
.lock()
.unwrap_or_else(|e| e.into_inner())
.clone()
}
/// 结束当前会话:**先静音**(立刻生效,避免它继续出声),再通知线程退出。
///
/// 只把会话从引擎里摘掉、不 join:调用方常在 Tauri 命令线程上,join 会把它卡住
/// 最长一个缓冲周期;线程收到 Stop 后自己收尾并丢弃输出流。会话 Arc 在这里
/// 释放后,JoinHandle 也随之丢弃,等于与线程解绑(detach),不会阻塞任何人。
fn stop_current(&self) {
let old = self.session.lock().unwrap_or_else(|e| e.into_inner()).take();
if let Some(old) = old {
old.shared.playing.store(false, Ordering::SeqCst);
// 让「已到末尾正在等缓冲放完」的等待立即退出,否则它要睡到自然结束
old.shared.finished.store(true, Ordering::SeqCst);
let _ = old.ctrl.send(Control::Stop);
}
}
}
impl Default for AudioEngine {
fn default() -> Self {
Self::new()
}
}
/// 播放线程主体:探测 → 建流 → 解码填缓冲,直到播完 / 被停止 / 出错。
fn run_session(
shared: &Arc<Shared>,
ctrl: &Receiver<Control>,
app: &AppHandle,
spec: &str,
start_sec: f64,
) -> Result<(), String> {
// ---------- 1) 打开音源并探测格式 ----------
let media_source = source::open(spec)?;
let mss = MediaSourceStream::new(media_source, Default::default());
// 扩展名能给探测器省不少事(本地文件尤其明显),流地址没有扩展名也无妨
let mut hint = Hint::new();
if let Some(ext) = extension_of(spec) {
hint.with_extension(&ext);
}
let mut format = symphonia::default::get_probe()
.probe(
&hint,
mss,
FormatOptions::default(),
MetadataOptions::default(),
)
.map_err(|e| format!("不支持的音频格式: {e}"))?;
let track = format
.default_track(TrackType::Audio)
.ok_or_else(|| "音频里没有可解码的轨道".to_string())?;
let params = track
.codec_params
.as_ref()
.and_then(|p| p.audio())
.ok_or_else(|| "音频轨道缺少编码参数".to_string())?;
// 采样率缺失时按 44.1k 兜底:宁可位置显示略有偏差,也不能让整首播不出来
let rate = params.sample_rate.unwrap_or(44100).max(1);
let src_ch = params
.channels
.as_ref()
.map(|c| c.count())
.unwrap_or(2)
.clamp(1, MAX_CHANNELS);
let mut decoder = symphonia::default::get_codecs()
.make_audio_decoder(params, &AudioDecoderOptions::default())
.map_err(|e| format!("不支持的音频编码: {e}"))?;
let track_id = track.id;
shared.rate.store(rate, Ordering::SeqCst);
shared.src_channels.store(src_ch as u16, Ordering::SeqCst);
// ---------- 2) 处理起始定位 ----------
let start_frames = (start_sec.max(0.0) * rate as f64).round() as u64;
shared.frames_played.store(start_frames, Ordering::SeqCst);
let mut produced = start_frames;
if start_sec > 0.0 {
seek_format(&mut *format, track_id, start_sec).map_err(|e| format!("续播定位失败: {e}"))?;
decoder.reset();
}
// ---------- 3) 建输出流 ----------
// 必须在**本线程**创建(cpal::Stream 不是 Send),并持有到会话结束
let _stream = output::build(shared)?;
// ---------- 4) 解码循环 ----------
let cap_samples = (rate as f64 * src_ch as f64 * BUFFER_SECONDS) as usize;
let mut samples: Vec<f32> = Vec::new();
let mut eof = false;
loop {
// 控制消息优先:停止要让线程尽快退出、定位要让缓冲尽快换内容
match ctrl.try_recv() {
Ok(Control::Stop) | Err(TryRecvError::Disconnected) => return Ok(()),
Ok(Control::Seek(sec)) => {
let target = sec.max(0.0);
// 顺序很关键:**先清缓冲、把位置计数挪到目标,再去定位**。
//
// 外网连 NAS 时 `format.seek()` 要等一次网络往返(几百毫秒到数秒)。
// 若等它返回再改状态,这段时间里旧缓冲还在出声、帧计数也还在往前走,
// 前端拉到的仍是旧位置 —— 表现就是「拖完进度条先闪回原处,再跳到目标」。
// 先清后定位 = 立刻静音 + 位置立刻到位,网络到了再从目标点出声。
let prev_frames = shared.frames_played.load(Ordering::SeqCst);
let frames = (target * rate as f64).round() as u64;
shared.buf.lock().unwrap_or_else(|e| e.into_inner()).clear();
shared.frames_played.store(frames, Ordering::SeqCst);
produced = frames;
match seek_format(&mut *format, track_id, target) {
Ok(()) => {
decoder.reset();
eof = false;
}
Err(e) => {
// 定位失败:位置计数必须还原,否则界面会停在一个根本没播到的地方。
// 缓冲已被清空,解码会从原位置继续,所以还原计数是对的。
shared.frames_played.store(prev_frames, Ordering::SeqCst);
produced = prev_frames;
crate::logger::log_warn(
"music-audio",
&format!("定位失败({target}s): {e}"),
);
}
}
continue;
}
Err(TryRecvError::Empty) => {}
}
if shared.failed.load(Ordering::Relaxed) {
return Err("音频输出设备异常(已断开或被其他程序独占)".to_string());
}
// 末尾:等缓冲真正放完再报结束,否则会把还没播完的一两秒当成播完
if eof {
if shared.frames_played.load(Ordering::Relaxed) >= produced {
shared.finished.store(true, Ordering::SeqCst);
// 播完就不该再显示「播放中」:状态查询据此立刻回到暂停态,
// 前端在收到事件、切下一首之前不会看到一个假的播放中状态。
shared.playing.store(false, Ordering::SeqCst);
let _ = app.emit(crate::constants::events::MUSIC_AUDIO_ENDED, ());
return Ok(());
}
thread::sleep(Duration::from_millis(20));
continue;
}
// 暂停时不继续填缓冲(否则一会就堆到上限,白占内存)
if !shared.playing.load(Ordering::Relaxed) {
thread::sleep(Duration::from_millis(10));
continue;
}
if shared.queue_len() >= cap_samples {
thread::sleep(Duration::from_millis(5));
continue;
}
let packet = match format.next_packet() {
Ok(Some(p)) => p,
// 正常读完:源读到 EOF 时读写器返回 None
Ok(None) => {
eof = true;
continue;
}
// 轨道表变化(链式 OGG 物理流):按结束处理
Err(SymphoniaError::ResetRequired) => {
eof = true;
continue;
}
// 文件被截断导致的提前结束:当播完处理,不弹错误
Err(SymphoniaError::IoError(ref e))
if e.kind() == std::io::ErrorKind::UnexpectedEof =>
{
eof = true;
continue;
}
// 其余 IO 错误**不能**当结束:那会把「网络断了 / 读超时」伪装成
// 「这首歌播完了」,前端随即自动切下一首,用户只会觉得莫名跳歌。
// 正常读完走的是 Ok(None),所以这里一律按失败上报(前端会弹错误)。
Err(e) => return Err(format!("读取音频流失败: {e}")),
};
if packet.track_id != track_id {
continue;
}
match decoder.decode(&packet) {
Ok(audio) => {
let n = audio.samples_interleaved();
if n == 0 {
continue;
}
samples.resize(n, 0.0);
audio.copy_to_slice_interleaved(&mut samples);
let frames = (samples.len() / src_ch) as u64;
shared
.buf
.lock()
.unwrap_or_else(|e| e.into_inner())
.extend(samples.iter().copied());
produced = produced.saturating_add(frames);
}
// 坏包跳过:单包解不出来不该让整首断掉
Err(SymphoniaError::DecodeError(_)) | Err(SymphoniaError::IoError(_)) => {}
Err(e) => return Err(format!("解码失败: {e}")),
}
}
}
/// 让容器定位到指定秒(精确模式:容器会把定位点之后、目标之前的帧解出来丢弃)。
///
/// `Time` 的字段是私有的,只能走 `try_new(秒, 纳秒)`;把亚秒部分用纳秒传进去,
/// 拖进度条才能落到毫秒级而不是整秒。
fn seek_format(format: &mut dyn FormatReader, track_id: u32, sec: f64) -> Result<(), String> {
let sec = sec.max(0.0);
let whole = sec.floor();
let nanos = (((sec - whole) * 1e9).round() as i64).clamp(0, 999_999_999) as u32;
let time = Time::try_new(whole as i64, nanos).ok_or_else(|| "定位时间非法".to_string())?;
format
.seek(
SeekMode::Accurate,
SeekTo::Time {
time,
track_id: Some(track_id),
},
)
.map(|_| ())
.map_err(|e| e.to_string())
}
/// 从路径/URL 里取扩展名(用于探测提示)。带 query 的流地址要先把 query 去掉。
fn extension_of(spec: &str) -> Option<String> {
let path = spec.split(['?', '#']).next().unwrap_or(spec);
let name = path.rsplit(['/', '\\']).next().unwrap_or(path);
let ext = name.rsplit_once('.')?.1;
if ext.is_empty() || ext.len() > 5 || !ext.chars().all(|c| c.is_ascii_alphanumeric()) {
return None;
}
Some(ext.to_ascii_lowercase())
}
+68
View File
@@ -0,0 +1,68 @@
//! Rust 侧音乐播放:解码与输出全在后端,前端只发命令、读状态。
//!
//! 模块分工:
//! - [`engine`]:会话生命周期、线程模型、播放/暂停/定位/音量的对外接口与状态快照
//! - [`source`]:音源字节流(本地文件 / 飞牛流代理,支持 Range 定位)
//! - [`output`]:cpal 输出流与音频回调(含声道映射、音量斜坡)
//!
//! 命令层只做参数转发,不含业务逻辑;状态查询走**拉取**而非高频事件推送。
mod engine;
mod output;
mod source;
pub use engine::{AudioEngine, AudioState};
use tauri::{AppHandle, State};
/// 开始播放一个音源。
///
/// `source`:本地绝对路径,或飞牛流地址(形如
/// `http://127.0.0.1:<port>/feiniu/stream?guid=...`,由前端按当前连接拼好 ——
/// 鉴权留在原有代理里,引擎不重复实现)。
/// `startSec`:起播位置,用于「恢复上次退出时的进度」。
#[tauri::command]
#[specta::specta]
pub fn music_audio_play(
app: AppHandle,
engine: State<'_, AudioEngine>,
source: String,
start_sec: f64,
) -> Result<(), String> {
engine.play(&app, source, start_sec)
}
/// 暂停 / 恢复。瞬时生效(只改一个原子标志)。
#[tauri::command]
#[specta::specta]
pub fn music_audio_set_playing(engine: State<'_, AudioEngine>, playing: bool) {
engine.set_playing(playing);
}
/// 定位到指定秒。
#[tauri::command]
#[specta::specta]
pub fn music_audio_seek(engine: State<'_, AudioEngine>, sec: f64) {
engine.seek(sec);
}
/// 停止播放并释放音频设备。
#[tauri::command]
#[specta::specta]
pub fn music_audio_stop(engine: State<'_, AudioEngine>) {
engine.stop();
}
/// 设置音量与静音(跨曲目沿用)。
#[tauri::command]
#[specta::specta]
pub fn music_audio_set_volume(engine: State<'_, AudioEngine>, volume: f32, muted: bool) {
engine.set_volume(volume, muted);
}
/// 读取播放状态快照(位置/缓冲/采样率/是否失败)。
#[tauri::command]
#[specta::specta]
pub fn music_audio_state(engine: State<'_, AudioEngine>) -> AudioState {
engine.state()
}
+175
View File
@@ -0,0 +1,175 @@
//! cpal 输出流:把缓冲里的交错 f32 样本按设备格式喂给声卡。
//!
//! # 采样率策略(关系到音质)
//!
//! cpal 的 WASAPI **共享模式**输出带 `AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM |
//! AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY`,因此**可以用源采样率直接建流**,
//! 由 Windows 自己转换到设备混音格式。这样做的两个好处:
//!
//! 1. 不必自己引入重采样器,也就不会临时用一版质量不明的 SRC 把音质拉低;
//! 2. 与现状(WebView2 内部同样把音频交给共享模式输出)**同级**,不构成退步。
//!
//! 后续要做 bit-perfect(独占模式)时,只需把这里换成独占模式的 `IAudioClient`
//! 初始化:源采样率直出、绕过 Windows 混音器,届时**必须**要求源采样率与设备一致,
//! 否则要自己做高质量重采样。
//!
//! # 线程归属
//!
//! `cpal::Stream` 在 Windows 上不是 `Send`,**必须**在创建它的线程上持有与丢弃。
//! 因此本模块只提供 [`build`],由播放线程调用并把返回的流保存在自己内部。
use std::sync::atomic::Ordering;
use std::sync::Arc;
use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
use super::engine::Shared;
/// 建立输出流并立即启动。**必须在播放线程上调用**(见模块注释的线程归属说明)。
pub fn build(shared: &Arc<Shared>) -> Result<cpal::Stream, String> {
let host = cpal::default_host();
let device = host
.default_output_device()
.ok_or_else(|| "没有可用的默认音频输出设备".to_string())?;
let supported = device
.default_output_config()
.map_err(|e| format!("读取默认输出配置失败: {e}"))?;
let sample_format = supported.sample_format();
let out_channels = supported.channels();
let rate = shared.rate.load(Ordering::Relaxed);
shared.out_channels.store(out_channels, Ordering::Relaxed);
// 声道数用**设备**的(AUTOCONVERTPCM 只保证采样率可任意,声道布局仍按设备来),
// 采样率用**源**的。解码出来的样本在 fill() 里做声道映射。
let config = cpal::StreamConfig {
channels: out_channels,
sample_rate: rate.into(),
buffer_size: cpal::BufferSize::Default,
};
let stream = match sample_format {
cpal::SampleFormat::F32 => build_typed::<f32>(&device, config, shared.clone()),
cpal::SampleFormat::I16 => build_typed::<i16>(&device, config, shared.clone()),
cpal::SampleFormat::I32 => build_typed::<i32>(&device, config, shared.clone()),
cpal::SampleFormat::U16 => build_typed::<u16>(&device, config, shared.clone()),
other => Err(format!("不支持的输出采样格式: {other:?}")),
}?;
stream
.play()
.map_err(|e| format!("启动音频输出失败: {e}"))?;
Ok(stream)
}
/// 按设备默认采样格式建流,回调里统一用 f32 计算、再转成设备格式输出。
fn build_typed<T>(
device: &cpal::Device,
config: cpal::StreamConfig,
shared: Arc<Shared>,
) -> Result<cpal::Stream, String>
where
T: cpal::SizedSample + cpal::FromSample<f32>,
{
let err_shared = shared.clone();
device
.build_output_stream(
config,
move |data: &mut [T], _| fill(data, &shared),
move |e| {
// 设备被拔掉 / 被独占 / 驱动异常:只记日志并把会话标记为失败,
// 由引擎把错误转成前端提示。这里**不能** panic —— 它在音频线程上。
crate::logger::log_error("music-audio", &format!("音频输出流错误: {e}"));
err_shared.failed.store(true, Ordering::Relaxed);
},
None,
)
.map_err(|e| format!("创建音频输出流失败: {e}"))
}
/// 音频回调:把队列里的交错样本搬进设备缓冲。
///
/// 全程只做「出队 + 乘增益 + 转格式」,不加锁以外的任何分配/系统调用,
/// 以免在实时线程上引入不可控的延迟(会直接表现为爆音)。
fn fill<T>(data: &mut [T], shared: &Shared)
where
T: cpal::SizedSample + cpal::FromSample<f32>,
{
let out_ch = shared.out_channels.load(Ordering::Relaxed) as usize;
let src_ch = shared.src_channels.load(Ordering::Relaxed) as usize;
// 尚未确定声道数(刚起会话)或异常值:先输出静音,不能除零
if out_ch == 0 || src_ch == 0 {
for s in data.iter_mut() {
*s = T::from_sample(0.0);
}
return;
}
// 暂停:输出静音但**不消费队列**,恢复播放时数据不丢
if !shared.playing.load(Ordering::Relaxed) {
for s in data.iter_mut() {
*s = T::from_sample(0.0);
}
return;
}
let target = if shared.muted.load(Ordering::Relaxed) {
0.0
} else {
f32::from_bits(shared.volume.load(Ordering::Relaxed))
};
let mut gain = f32::from_bits(shared.gain.load(Ordering::Relaxed));
let frames = data.len() / out_ch;
// 音量在本块内线性走到目标值:拖动音量滑块/切静音时不会有台阶式的爆音。
let step = if frames > 0 {
(target - gain) / frames as f32
} else {
0.0
};
let mut consumed: u64 = 0;
{
let mut queue = shared.buf.lock().unwrap_or_else(|e| e.into_inner());
for f in 0..frames {
gain += step;
let base = f * out_ch;
// 一帧源数据 = src_ch 个样本;不足一帧(解码没跟上)就整帧输出静音
let mut src = [0f32; 8];
let has_frame = queue.len() >= src_ch;
if has_frame {
for slot in src.iter_mut().take(src_ch.min(8)) {
*slot = queue.pop_front().unwrap_or(0.0);
}
consumed += 1;
}
for c in 0..out_ch {
let v = if !has_frame {
0.0
} else if out_ch == 1 && src_ch > 1 {
// 多声道 → 单声道:取平均,避免只留左声道
let n = src_ch.min(8);
src[..n].iter().sum::<f32>() / n as f32
} else if src_ch == 1 {
// 单声道 → 任意声道数:复制
src[0]
} else if c < src_ch.min(8) {
src[c]
} else {
// 源声道数少于设备声道数:多出来的声道填静音
0.0
};
data[base + c] = T::from_sample(v * gain);
}
}
}
if consumed > 0 {
shared.frames_played.fetch_add(consumed, Ordering::Relaxed);
}
shared.gain.store(gain.to_bits(), Ordering::Relaxed);
}
+179
View File
@@ -0,0 +1,179 @@
//! 音频字节源:给 symphonia 提供同步的 [`MediaSource`](`Read` + `Seek`)。
//!
//! 两类来源:
//! - **本地文件**:直接交给 `std::fs::File`(symphonia 已为它实现 `MediaSource`)。
//! - **飞牛流**:复用**现有的本地流代理** `http://127.0.0.1:<port>/feiniu/stream?guid=...`。
//! 代理已经处理好登录态 / Cookie / 安全码 / Range 透传,这里只按 Range 拉取即可。
//!
//! 为什么走本地代理而不让引擎直连 NAS:鉴权(连接选择、token、安全码)全在代理里,
//! 复制一份到引擎会立刻产生两套会漂移的逻辑;代理就在 localhost,额外一跳代价可忽略。
//!
//! # 为什么是同步 I/O
//!
//! `MediaSource` 要求 `Read + Seek`,即同步接口。整个播放线程是**独立的 std 线程**
//! (不是 tokio 运行时线程),因此这里用 `reqwest::blocking` 是安全的;若在 tokio
//! 运行时线程上调用会 panic,这一点在改动线程归属时必须留意。
use std::io::{self, Read, Seek, SeekFrom};
use std::time::Duration;
use symphonia::core::io::MediaSource;
/// NAS 流的超时策略:只在**连接**阶段设超时。
///
/// 音频是长时间连续读,一旦给整请求设 timeout,会在播到中途时被掐断(表现为
/// 「播一半突然断流」);而不设连接超时又会在服务器无响应时永久挂住播放线程。
///
/// # 已知限制:读阶段的卡死不设上限
///
/// 想给「连接建立后数据不再来」也加个上限,但 reqwest 的 `read_timeout` 只在**异步**
/// builder 上(blocking 侧没有),而总 timeout 又会掐断长音频。因此链路彻底卡死时
/// 解码线程会停在那次读上(界面表现为一直加载),要等 TCP 自身超时才会报错。
/// 真要兜住它,得在会话上加一个「位置长时间不前进」的看门狗,或让 HttpSource 自己能
/// 被从外部关闭 —— 目前没做。
const CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
/// 按规格打开字节源:`http(s)://` 走网络协议,其余一律按本地文件路径处理。
pub fn open(spec: &str) -> Result<Box<dyn MediaSource>, String> {
if spec.starts_with("http://") || spec.starts_with("https://") {
Ok(Box::new(HttpSource::new(spec)?))
} else {
let file = std::fs::File::open(spec).map_err(|e| format!("打开本地音频失败({spec}): {e}"))?;
Ok(Box::new(file))
}
}
/// 走 HTTP 的流式音源,支持按 `Range` 定位。
pub struct HttpSource {
url: String,
client: reqwest::blocking::Client,
/// 已建立的响应体。定位后置空,下次读取时按新位置重新发 Range 请求。
body: Option<reqwest::blocking::Response>,
/// 当前读取位置(字节)
pos: u64,
/// 总字节数(服务端给出 Content-Range / Content-Length 时才有)
len: Option<u64>,
/// 服务端是否支持 Range。不支持时无法定位,引擎会退化为「只能从头顺序播」。
range_ok: bool,
}
impl HttpSource {
fn new(url: &str) -> Result<Self, String> {
let client = reqwest::blocking::Client::builder()
.connect_timeout(CONNECT_TIMEOUT)
.timeout(None)
.build()
.map_err(|e| format!("创建音频 HTTP 客户端失败: {e}"))?;
// 探测总长度与 Range 支持:只取 0-0 一个字节。
// 支持 Range 时服务端回 `206 Partial Content` + `Content-Range: bytes 0-0/<total>`;
// 不支持则回 `200` + `Content-Length`。两种情况都能拿到总长度。
let probe = client
.get(url)
.header(reqwest::header::RANGE, "bytes=0-0")
.send()
.map_err(|e| format!("音频源探测失败: {e}"))?;
let status = probe.status();
if !status.is_success() {
return Err(format!("音频源探测失败: HTTP {status}"));
}
let range_ok = status == reqwest::StatusCode::PARTIAL_CONTENT
|| probe
.headers()
.get(reqwest::header::ACCEPT_RANGES)
.is_some();
let len = parse_content_range_total(&probe)
.or_else(|| probe.content_length().map(|n| n.max(1)));
Ok(Self {
url: url.to_string(),
client,
body: None,
pos: 0,
len,
range_ok,
})
}
/// 打开(或按当前 `pos` 重开)响应体。
fn ensure_body(&mut self) -> io::Result<()> {
if self.body.is_some() {
return Ok(());
}
let mut req = self.client.get(&self.url);
if self.pos > 0 {
if !self.range_ok {
return Err(io::Error::new(
io::ErrorKind::Unsupported,
"音频源不支持 Range,无法定位",
));
}
req = req.header(reqwest::header::RANGE, format!("bytes={}-", self.pos));
}
let resp = req.send().map_err(to_io_err)?;
if !resp.status().is_success() {
return Err(io::Error::new(
io::ErrorKind::Other,
format!("音频流请求失败: HTTP {}", resp.status()),
));
}
self.body = Some(resp);
Ok(())
}
}
impl Read for HttpSource {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
self.ensure_body()?;
let body = self.body.as_mut().expect("ensure_body 已建立响应体");
let n = body.read(buf)?;
self.pos += n as u64;
Ok(n)
}
}
impl Seek for HttpSource {
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
let target = match pos {
SeekFrom::Start(p) => p,
SeekFrom::End(off) => {
let len = self.len.ok_or_else(|| {
io::Error::new(io::ErrorKind::Unsupported, "总长度未知,无法从末尾定位")
})?;
(len as i64 + off).max(0) as u64
}
SeekFrom::Current(off) => (self.pos as i64 + off).max(0) as u64,
};
// 丢弃当前响应体,下次读取按新位置重发 Range —— 这样定位既不需要缓存整段音频,
// 也不会把已读过的字节再拉一遍。
self.body = None;
self.pos = target;
Ok(target)
}
}
impl MediaSource for HttpSource {
fn is_seekable(&self) -> bool {
self.range_ok
}
fn byte_len(&self) -> Option<u64> {
self.len
}
}
/// 解析 `Content-Range: bytes 0-0/12345` 里的总长度。
fn parse_content_range_total(resp: &reqwest::blocking::Response) -> Option<u64> {
let raw = resp.headers().get(reqwest::header::CONTENT_RANGE)?.to_str().ok()?;
let total = raw.rsplit('/').next()?.trim();
if total == "*" {
return None;
}
total.parse::<u64>().ok()
}
/// reqwest 的 `Error` → `io::Error`(symphonia 只认 io 错误)。
fn to_io_err(e: reqwest::Error) -> io::Error {
io::Error::new(io::ErrorKind::Other, e.to_string())
}
+13
View File
@@ -14,17 +14,30 @@
//! - [`runtime`]:Python 运行时探测与便携版安装
//! - [`bridge`]:桥接进程生命周期(spawn / JSON 协议 / ping / 停止)
//! - [`commands`]:Tauri 命令层
//! - [`smtc`]:Windows 系统媒体传输控件(原生,取代前端 navigator.mediaSession 元数据)
mod audio;
mod bridge;
mod commands;
mod feiniu;
mod runtime;
mod secrets;
mod smtc;
pub use audio::{
music_audio_play, music_audio_seek, music_audio_set_playing, music_audio_set_volume,
music_audio_state, music_audio_stop, AudioEngine,
};
pub use feiniu::{
extract_fn_id, normalize_base_url, resolve_base_url, scan_local_dirs, Feiniu, FeiniuConnection,
};
pub use smtc::{
music_smtc_clear, music_smtc_update_metadata, music_smtc_update_playback_state,
music_smtc_update_position, SmtcController,
};
pub use commands::{
feiniu_activate_connection, feiniu_cache_clear, feiniu_cache_fetch, feiniu_cache_status,
feiniu_delete_connection, feiniu_delete_local, feiniu_fnconnect_resolve, feiniu_get_config,
+393
View File
@@ -0,0 +1,393 @@
//! Windows 系统媒体传输控件(SMTC)集成。
//!
//! # 为什么不用前端的 `navigator.mediaSession`
//!
//! WebView2(Chromium 内核)确实会把 `navigator.mediaSession` 桥接到 Windows SMTC,
//! 但实测**只转发标题、歌手、播放状态与时长进度**:专辑(`AlbumTitle` / `AlbumArtist` /
//! `Subtitle` 全为空)与封面(同一首曲子缩略图时有时无)都不会送达;
//! 且会话挂在 WebView2 浏览器进程的 AUMID 上,系统面板只显示「未知应用」。
//! 因此这里改用原生 SMTC 直接投递全部字段:歌名、歌手、专辑、时长、进度、封面,
//! 并把系统侧的按钮(播放/暂停/上一首/下一首/停止)回传前端。
//!
//! # 与 WebView2 自动会话的关系(当前未解决,系统面板会同时出现两条「媒体」)
//!
//! Chromium 会为播放中的 `<audio>` 自动再注册一条 SMTC 会话,和本模块并行时
//! 系统面板会出现两条「媒体」。已排除的三条压制路径:
//!
//! - **前端把 `navigator.mediaSession` 置空**:无效。那条会话由浏览器进程按 WebContents
//! 的播放状态创建,**与页面碰不碰 mediaSession 无关**;JS 侧置空只是不再往会话里写
//! 元数据,拦不住它的注册。
//! - **`WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS` 环境变量**(关掉 MediaSessionService):
//! 无效。本应用支持永久提权,而提权进程下 WebView2 会忽略所有 WEBVIEW2_* 环境变量
//! (微软文档 *Develop secure WebView2 apps → For an elevated host app*)。
//! - **`tauri.conf.json` 的 `additionalBrowserArgs`**:能关掉 Chromium 那条会话,但代价是
//! 把这个应用的其他窗口一起弄死——参数只落在主窗口,其余弹窗走 wry 默认参数,两者却
//! 共用同一个 EBWebView 用户数据目录。结果是托盘菜单/截图/剪贴板等窗口的页面**永远
//! 不执行 JS**(日志里没有任何 `xxx窗口启动` 记录),因而永远唤不出;启动也会偶发
//! 卡住一两分钟。
//!
//! 根治只能让主窗口不再持有 `<audio>`(播放搬到 Rust 侧):Chromium 无会话可注册,
//! 也就不需要任何浏览器参数。
//!
//! # 线程与套间
//!
//! `SystemMediaTransportControls` 通过
//! [`ISystemMediaTransportControlsInterop::GetForWindow`] 绑定到主窗口 HWND。
//! WinRT 对象要求所在线程已初始化 COM:主线程由 WebView2 完成初始化,而 tokio 工作线程
//! 没有,因此所有 SMTC 调用统一 `run_on_main_thread` 抛到主线程执行
//! (对象本身是 agile 的,跨线程只涉及调用点,不涉及状态迁移)。
//!
//! # 失败策略
//!
//! 系统媒体控件属于「锦上添花」:任何一步失败都只记日志,绝不影响播放本身。
use std::sync::Mutex;
use tauri::{AppHandle, Emitter, Manager};
use windows::core::{factory, HSTRING};
use windows::Foundation::{TimeSpan, TypedEventHandler};
use windows::Media::{
MediaPlaybackStatus, MediaPlaybackType, SystemMediaTransportControls,
SystemMediaTransportControlsButton, SystemMediaTransportControlsButtonPressedEventArgs,
SystemMediaTransportControlsTimelineProperties,
};
use windows::Storage::Streams::RandomAccessStreamReference;
use windows::Win32::Foundation::HWND;
use windows::Win32::System::WinRT::ISystemMediaTransportControlsInterop;
/// 系统媒体控件按钮事件名:前端监听它来执行播放/暂停/切歌/停止。
pub const SMTC_BUTTON_EVENT: &str = "music-smtc-button";
/// 100 纳秒 ticks/秒(WinRT `TimeSpan` 的单位)。
const TICKS_PER_SEC: f64 = 10_000_000.0;
/// SMTC 控制器:惰性绑定主窗口后缓存。
pub struct SmtcController {
ctrl: Mutex<Option<SystemMediaTransportControls>>,
}
impl SmtcController {
pub fn new() -> Self {
Self {
ctrl: Mutex::new(None),
}
}
}
impl Default for SmtcController {
fn default() -> Self {
Self::new()
}
}
/// 秒 → WinRT `TimeSpan`(100ns ticks),负数与非有限值按 0 处理。
fn ticks(sec: f64) -> TimeSpan {
let v = if sec.is_finite() && sec > 0.0 { sec } else { 0.0 };
TimeSpan {
Duration: (v * TICKS_PER_SEC) as i64,
}
}
/// 取(必要时创建)SMTC 控制器。**必须在主线程调用**。
fn ensure_controls(app: &AppHandle) -> Result<SystemMediaTransportControls, String> {
let state = app.state::<SmtcController>();
if let Some(c) = state
.ctrl
.lock()
.unwrap_or_else(|e| e.into_inner())
.clone()
{
return Ok(c);
}
let window = app.get_webview_window("main").ok_or("主窗口不存在")?;
let hwnd = window.hwnd().map_err(|e| format!("取窗口句柄失败: {e}"))?;
let interop: ISystemMediaTransportControlsInterop =
factory::<SystemMediaTransportControls, ISystemMediaTransportControlsInterop>()
.map_err(|e| format!("取 SMTC 工厂失败: {e}"))?;
// SAFETY: HWND 来自当前进程的真实主窗口,且在调用期间保持有效。
let ctrl: SystemMediaTransportControls = unsafe {
interop
.GetForWindow(HWND(hwnd.0 as isize))
.map_err(|e| format!("SMTC GetForWindow 失败: {e}"))?
};
// 系统侧按钮 → 前端事件(事件可能从任意线程触发,emit 本身线程安全)。
// 注册失败**不**中断初始化:元数据/封面是主要目的,按钮是附加能力。
let emitter = app.clone();
let handler = TypedEventHandler::<
SystemMediaTransportControls,
SystemMediaTransportControlsButtonPressedEventArgs,
>::new(move |_, args| {
if let Some(args) = args.as_ref() {
if let Ok(button) = args.Button() {
let name = if button == SystemMediaTransportControlsButton::Play {
"play"
} else if button == SystemMediaTransportControlsButton::Pause {
"pause"
} else if button == SystemMediaTransportControlsButton::Next {
"next"
} else if button == SystemMediaTransportControlsButton::Previous {
"prev"
} else if button == SystemMediaTransportControlsButton::Stop {
"stop"
} else {
""
};
if !name.is_empty() {
let _ = emitter.emit(SMTC_BUTTON_EVENT, name);
}
}
}
Ok(())
});
if let Err(e) = ctrl.ButtonPressed(&handler) {
crate::logger::log_error("music", &format!("注册 SMTC 按钮事件失败(按钮不可用): {e}"));
}
// 启用按钮(不启用的话系统面板上的按钮是灰的)
let _ = ctrl.SetIsEnabled(true);
let _ = ctrl.SetIsPlayEnabled(true);
let _ = ctrl.SetIsPauseEnabled(true);
let _ = ctrl.SetIsStopEnabled(true);
let _ = ctrl.SetIsNextEnabled(true);
let _ = ctrl.SetIsPreviousEnabled(true);
*state.ctrl.lock().unwrap_or_else(|e| e.into_inner()) = Some(ctrl.clone());
crate::logger::log_info("music", "SMTC 已初始化(原生系统媒体控件已绑定主窗口)");
Ok(ctrl)
}
/// 把一次 SMTC 操作抛到主线程执行;失败只记日志。
fn on_main<F>(app: &AppHandle, what: &'static str, f: F)
where
F: FnOnce(&SystemMediaTransportControls) + Send + 'static,
{
let app = app.clone();
if let Err(e) = app.clone().run_on_main_thread(move || {
match ensure_controls(&app) {
Ok(ctrl) => f(&ctrl),
Err(e) => crate::logger::log_error("music", &format!("SMTC {what} 失败: {e}")),
}
}) {
crate::logger::log_error("music", &format!("SMTC {what} 投递主线程失败: {e}"));
}
}
/// 更新曲目信息:歌名 / 歌手 / 专辑 / 封面。
///
/// 封面**由我们自己下载字节**再写进内存流交给 SMTC:早先让系统按 URI 自行取图
/// (`RandomAccessStreamReference::CreateFromUri`)实测拿不到(本地代理地址与外链都静默失败),
/// 自取字节才能保证取到的是界面上显示的那张图。
///
/// `cover_url` 为空表示该曲目没有封面——此时必须清掉上一次的缩略图,
/// 否则换到无封面的曲子会继续显示上一首的封面。
#[tauri::command]
#[specta::specta]
pub async fn music_smtc_update_metadata(
app: AppHandle,
title: String,
artist: String,
album: String,
cover_url: Option<String>,
) {
// 下载放在 tokio 线程(主线程不能阻塞);失败只跳过封面,不影响标题/歌手/专辑
let cover = match cover_url.as_deref().filter(|u| !u.is_empty()) {
Some(url) => {
let raw = download_cover(url).await;
// SMTC 的缩略图解码器不认 WebP(飞牛封面接口返回的就是 WebP),
// 必须转成 PNG/JPEG,否则 SetThumbnail 静默失败、面板上永远没有封面
let bytes = raw.as_deref().and_then(normalize_cover_format);
// 留痕便于定位「面板上没有封面」到底是没传地址、下载失败还是格式不支持
crate::logger::log_info(
"music",
&format!(
"SMTC 封面: {url} → {}",
match (&raw, &bytes) {
(None, _) => "下载失败".to_string(),
(Some(r), Some(b)) if r.len() == b.len() => format!("{} 字节", r.len()),
(Some(r), Some(b)) => format!("{} 字节 → 转码后 {} 字节", r.len(), b.len()),
(Some(r), None) => format!("{} 字节但无法解码为图片", r.len()),
}
),
);
bytes
}
None => {
crate::logger::log_info("music", "SMTC 封面: 该曲目未提供封面地址");
None
}
};
on_main(&app, "metadata", move |ctrl| {
apply_metadata(ctrl, &title, &artist, &album, cover.as_deref());
});
}
/// 把元数据与封面写进 SMTC(主线程执行)。
fn apply_metadata(
ctrl: &SystemMediaTransportControls,
title: &str,
artist: &str,
album: &str,
cover: Option<&[u8]>,
) {
let Ok(updater) = ctrl.DisplayUpdater() else {
return;
};
// ClearAll 会连元数据一起清,因此无封面时先清再整体重写(顺序不能颠倒)
if cover.is_none() {
let _ = updater.ClearAll();
}
let _ = updater.SetType(MediaPlaybackType::Music);
if let Ok(props) = updater.MusicProperties() {
let _ = props.SetTitle(&HSTRING::from(title));
let _ = props.SetArtist(&HSTRING::from(artist));
let _ = props.SetAlbumTitle(&HSTRING::from(album));
}
if let Some(bytes) = cover {
match stream_reference_from_bytes(bytes) {
Ok(reference) => {
let _ = updater.SetThumbnail(&reference);
}
Err(e) => crate::logger::log_error("music", &format!("设置 SMTC 封面失败: {e}")),
}
}
let _ = updater.Update();
}
/// 把封面字节统一成 SMTC 能解码的格式(PNG)。
///
/// Windows 系统媒体面板的缩略图解码器只认常见位图格式,**不认 WebP**——而飞牛封面接口
/// 返回的正是 WebP(`image/webp`)。不转码的话 `SetThumbnail` 会静默失败,
/// 表现就是「歌名/歌手/专辑都对,就是没有封面」。
/// 已经是 PNG/JPEG 时原样返回,避免无谓的重新编码。
fn normalize_cover_format(bytes: &[u8]) -> Option<Vec<u8>> {
use image::ImageFormat;
match image::guess_format(bytes) {
Ok(ImageFormat::Png) | Ok(ImageFormat::Jpeg) => Some(bytes.to_vec()),
Ok(other) => match image::load_from_memory(bytes) {
Ok(img) => {
let mut out = std::io::Cursor::new(Vec::new());
match img.write_to(&mut out, ImageFormat::Png) {
Ok(()) => Some(out.into_inner()),
Err(e) => {
crate::logger::log_error("music", &format!("封面转 PNG 失败({other:?}): {e}"));
None
}
}
}
Err(e) => {
crate::logger::log_error("music", &format!("封面解码失败({other:?}): {e}"));
None
}
},
Err(e) => {
crate::logger::log_error("music", &format!("无法识别封面格式: {e}"));
None
}
}
}
/// 下载封面图片字节;任何失败都返回 `None`(只记日志,不影响其余元数据)。
async fn download_cover(url: &str) -> Option<Vec<u8>> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(10))
.build()
.ok()?;
let resp = match client
.get(url)
.header("User-Agent", "Thing/1.0")
.send()
.await
{
Ok(r) if r.status().is_success() => r,
Ok(r) => {
crate::logger::log_error("music", &format!("封面下载失败(HTTP {}): {url}", r.status()));
return None;
}
Err(e) => {
crate::logger::log_error("music", &format!("封面下载失败({e}): {url}"));
return None;
}
};
match resp.bytes().await {
Ok(b) if !b.is_empty() => Some(b.to_vec()),
Ok(_) => None,
Err(e) => {
crate::logger::log_error("music", &format!("封面读取失败({e}): {url}"));
None
}
}
}
/// 把图片字节写进内存流,并包装成 SMTC 需要的流引用。
fn stream_reference_from_bytes(bytes: &[u8]) -> Result<RandomAccessStreamReference, String> {
use windows::Storage::Streams::{DataWriter, InMemoryRandomAccessStream};
let stream = InMemoryRandomAccessStream::new().map_err(|e| format!("创建内存流失败: {e}"))?;
let output = stream
.GetOutputStreamAt(0)
.map_err(|e| format!("取输出流失败: {e}"))?;
let writer = DataWriter::CreateDataWriter(&output).map_err(|e| format!("创建写入器失败: {e}"))?;
writer
.WriteBytes(bytes)
.map_err(|e| format!("写入封面字节失败: {e}"))?;
// 内存流的异步写入会立刻完成,这里同步等待即可(get() 阻塞至完成)
writer
.StoreAsync()
.map_err(|e| format!("提交封面字节失败: {e}"))?
.get()
.map_err(|e| format!("提交封面字节失败: {e}"))?;
let _ = writer.FlushAsync();
// 读指针回到起点,否则 SMTC 会读到空数据
stream.Seek(0).map_err(|e| format!("复位流失败: {e}"))?;
RandomAccessStreamReference::CreateFromStream(&stream)
.map_err(|e| format!("创建流引用失败: {e}"))
}
/// 更新时长与当前进度(系统面板的进度条)。
#[tauri::command]
#[specta::specta]
pub fn music_smtc_update_position(app: AppHandle, position_sec: f64, duration_sec: f64) {
on_main(&app, "position", move |ctrl| {
let Ok(props) = SystemMediaTransportControlsTimelineProperties::new() else {
return;
};
let duration = ticks(duration_sec);
let _ = props.SetStartTime(ticks(0.0));
let _ = props.SetEndTime(duration);
let _ = props.SetMinSeekTime(ticks(0.0));
let _ = props.SetMaxSeekTime(duration);
let _ = props.SetPosition(ticks(position_sec.min(duration_sec)));
let _ = ctrl.UpdateTimelineProperties(&props);
});
}
/// 更新播放状态(系统面板据此显示播放/暂停按钮)。
#[tauri::command]
#[specta::specta]
pub fn music_smtc_update_playback_state(app: AppHandle, playing: bool) {
on_main(&app, "playback", move |ctrl| {
let status = if playing {
MediaPlaybackStatus::Playing
} else {
MediaPlaybackStatus::Paused
};
let _ = ctrl.SetPlaybackStatus(status);
});
}
/// 停止播放:清空曲目信息并从系统面板移除。
#[tauri::command]
#[specta::specta]
pub fn music_smtc_clear(app: AppHandle) {
on_main(&app, "clear", move |ctrl| {
let _ = ctrl.SetPlaybackStatus(MediaPlaybackStatus::Stopped);
if let Ok(updater) = ctrl.DisplayUpdater() {
let _ = updater.ClearAll();
let _ = updater.Update();
}
});
}
+20 -12
View File
@@ -204,8 +204,9 @@ pub async fn terminal_save_shell(
) -> Result<Vec<ShellProfile>, String> {
let m = manager(&app)?;
// 校验可执行文件存在:不存在的路径存进去,用户新建会话时才失败,
// 那时的错误信息离「配置错了」很远,很难定位。
if !std::path::Path::new(&shell_profile.path).is_file() {
// 那时的错误信息离「配置错了」很远,很难定位。裸命令名(如 `wsl.exe`)
// 按 PATH 解析后再校验,避免手填的命令名被误判为不存在。
if shell::resolve_executable(&shell_profile.path).is_none() {
return Err(format!("可执行文件不存在:{}", shell_profile.path));
}
if shell_profile.id.trim().is_empty() {
@@ -279,12 +280,14 @@ pub async fn terminal_open_local(
.cloned()
.ok_or_else(|| format!("Shell {shell_id} 不存在,请到终端设置中重新探测。"))?;
if !std::path::Path::new(&profile.path).is_file() {
return Err(format!(
// 存在性校验走 resolve_executable:老配置里 WSL 的 path 是裸命令名 `wsl.exe`,
// 按路径直接判存在会误报「可执行文件不存在」,这里允许用 PATH 把它解析出来。
let resolved = shell::resolve_executable(&profile.path).ok_or_else(|| {
format!(
"Shell 可执行文件不存在:{}。请重新探测或修正路径。",
profile.path
));
}
)
})?;
let id = m.sessions.next_session_id();
let cols = cols.unwrap_or(super::session::DEFAULT_COLS);
@@ -293,6 +296,7 @@ pub async fn terminal_open_local(
// ===== 组装命令行(含 cwd 跟踪 hook)=====
let (hook_args, _hook_file) = shell::cwd_hook_args(&profile, &m.hooks_dir());
let mut effective = profile.clone();
effective.path = resolved;
// hook 参数追加在用户参数之后:用户自定义参数优先(如 `-NoProfile`)
effective.args.extend(hook_args);
let command_line = shell::build_command_line(&effective);
@@ -1491,17 +1495,21 @@ pub async fn terminal_test_shell(shell_id: String, app: AppHandle) -> Result<Act
.cloned()
.ok_or_else(|| format!("Shell {shell_id} 不存在"))?;
if !std::path::Path::new(&profile.path).is_file() {
return Ok(ActionOutcome {
ok: false,
message: format!("可执行文件不存在:{}", profile.path),
});
}
let resolved = match shell::resolve_executable(&profile.path) {
Some(p) => p,
None => {
return Ok(ActionOutcome {
ok: false,
message: format!("可执行文件不存在:{}", profile.path),
})
}
};
// 真启动一次再立刻杀掉:比只检查文件存在更能发现问题
// (如缺少运行时依赖、参数非法、权限不足)
let (hook_args, _f) = shell::cwd_hook_args(&profile, &m.hooks_dir());
let mut eff = profile.clone();
eff.path = resolved;
eff.args.extend(hook_args);
let cmd = shell::build_command_line(&eff);
+57 -8
View File
@@ -117,17 +117,42 @@ pub fn detect_shells() -> Vec<ShellProfile> {
list.push(ShellProfile::new("gitbash", "Git Bash", &p, "bash"));
}
// WSL 发行版:每个发行版一个条目
for distro in list_wsl_distros() {
let id = format!("wsl-{}", sanitize_id(&distro));
let name = format!("WSL · {distro}");
let mut profile = ShellProfile::new(&id, &name, "wsl.exe", "wsl");
profile.args = vec!["-d".to_string(), distro];
list.push(profile);
if let Some(wsl) = find_wsl() {
for distro in list_wsl_distros(&wsl) {
let id = format!("wsl-{}", sanitize_id(&distro));
let name = format!("WSL · {distro}");
let mut profile = ShellProfile::new(&id, &name, &wsl, "wsl");
profile.args = vec!["-d".to_string(), distro];
list.push(profile);
}
}
list
}
/// 把配置里的可执行文件路径解析成**可直接启动**的路径。
///
/// - 已存在的路径 → 原样返回;
/// - 裸命令名(不含路径分隔符,如老配置里存下的 `wsl.exe`)→ 查 PATH。
///
/// 存在这层解析是因为「探测」与「连接」对路径的要求不同:探测时用
/// `Command::new("wsl.exe")` 由系统搜索 PATH 即可跑通,但存进设置的值随后要
/// 按**路径**判存在(见 `terminal_open_session`),裸命令名会被判成「文件不存在」,
/// 表现为「探测到了 WSL,点连接却报找不到 wsl.exe」。
pub fn resolve_executable(path: &str) -> Option<String> {
let p = path.trim();
if p.is_empty() {
return None;
}
if Path::new(p).is_file() {
return Some(p.to_string());
}
if !p.contains('\\') && !p.contains('/') {
return find_in_path(&[p]);
}
None
}
/// 在 PATH 中查找可执行文件。
fn find_in_path(names: &[&str]) -> Option<String> {
let path = std::env::var_os("PATH")?;
@@ -203,12 +228,36 @@ fn find_git_bash() -> Option<String> {
})
}
/// 定位 `wsl.exe`。
///
/// 优先系统目录(权威路径,避免 PATH 上的同名伪装程序),其次
/// `WindowsApps` 下的应用执行别名,最后才查 PATH。
fn find_wsl() -> Option<String> {
let root = std::env::var_os("SystemRoot")
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from(r"C:\Windows"));
let sys = root.join("System32").join("wsl.exe");
if sys.is_file() {
return Some(sys.to_string_lossy().to_string());
}
if let Some(local) = std::env::var_os("LOCALAPPDATA") {
let alias = PathBuf::from(local)
.join("Microsoft")
.join("WindowsApps")
.join("wsl.exe");
if alias.is_file() {
return Some(alias.to_string_lossy().to_string());
}
}
find_in_path(&["wsl.exe"])
}
/// 枚举 WSL 发行版。
///
/// `wsl.exe -l -q` 输出 UTF-16LE(Windows 上部分 wsl.exe 版本如此),
/// 先按 UTF-16 解,失败再按 UTF-8 解。输出每行一个发行版名。
fn list_wsl_distros() -> Vec<String> {
let out = match std::process::Command::new("wsl.exe")
fn list_wsl_distros(wsl_exe: &str) -> Vec<String> {
let out = match std::process::Command::new(wsl_exe)
.args(["-l", "-q"])
.creation_flags_no_window()
.output()
+18
View File
@@ -3,6 +3,24 @@
//! 从 `clipboard::popup` 迁出,供剪贴板弹窗、快速面板、托盘菜单等多窗口模块统一引用,
//! 避免其他模块反向依赖剪贴板模块。
/// 设置进程的 AppUserModelID(AUMID)。
///
/// Windows 的系统媒体面板(SMTC)与任务栏都按 AUMID 反查应用显示名与图标:进程不设置时
/// 系统只能显示「未知应用」。这里传入安装包写进开始菜单快捷方式的同一个标识符
/// (即 Tauri 的 identifier),从而直接复用快捷方式里的名称与图标。
///
/// **必须在创建任何窗口之前调用**(Windows 在窗口创建时确定任务栏分组与身份)。
#[cfg(windows)]
pub fn set_app_user_model_id(app_id: &str) {
use windows_sys::Win32::UI::Shell::SetCurrentProcessExplicitAppUserModelID;
let wide: Vec<u16> = app_id.encode_utf16().chain(std::iter::once(0)).collect();
// SAFETY: wide 以 NUL 结尾,且在本调用期间保持存活
unsafe {
SetCurrentProcessExplicitAppUserModelID(wide.as_ptr());
}
}
/// 获取鼠标位置(屏幕坐标,物理像素)
#[cfg(windows)]
pub fn get_cursor_pos() -> Option<(i32, i32)> {
+1 -1
View File
@@ -1,7 +1,7 @@
{
"$schema": "https://schema.tauri.app/config/2",
"productName": "thing",
"version": "26.9.3",
"version": "26.9.4",
"identifier": "thing.lfeng.me",
"build": {
"beforeDevCommand": "bun run dev",