音乐控制/解密
This commit is contained in:
1 parent
9e6d73e191
commit
ff1d5cd517
41 files changed
+10827
-4
No files matched your search
@@ -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"));
|
||||
}
|
||||
}
|
||||
@@ -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}"))
|
||||
}
|
||||
@@ -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),
|
||||
});
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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}"))?
|
||||
}
|
||||
@@ -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(())
|
||||
}
|
||||
Reference in new issue
Block a user