音乐控制/解密

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

No files matched your search

+181
View File
@@ -0,0 +1,181 @@
//! 设备发现:UDP beacon(MUSIC_REMOTE_PLAN §3.3,P0 主路径)。
//!
//! 电脑每 3s 向 `255.255.255.255:26123` **与各网卡的定向广播地址**发 JSON 包;
//! 手机被动监听 26123 收集。beacon 不含任何敏感信息(无 token、无配对码)。
//!
//! 各网卡定向广播是必须的:本机常驻 VPN/虚拟网卡(mihomo 等),默认路由可能
//! 不在 LAN 网卡上,仅发 255.255.255.255 会从默认路由出去、手机收不到(§8 风险行
//! "多网卡/VPN 虚拟网卡"的对策)。地址枚举走 `GetAdaptersAddresses`。
use std::net::{Ipv4Addr, UdpSocket};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::thread::JoinHandle;
use std::time::Duration;
/// 手机监听的 beacon 端口(与 LFMusic `bind :26123` 对齐)。
pub const BEACON_PORT: u16 = 26123;
/// beacon 广播周期(与对端文档 §5.1"每 3s 广播"对齐)。
const BEACON_INTERVAL: Duration = Duration::from_secs(3);
/// beacon 负载(§3.3)。`addrs` 供手机在多地址场景按连通性优选(§8 对策)。
#[derive(Clone, serde::Serialize)]
pub struct BeaconPayload {
pub service: &'static str,
#[serde(rename = "deviceId")]
pub device_id: String,
pub name: String,
pub port: u16,
#[serde(rename = "protoVer")]
pub proto_ver: u32,
/// 本机各网卡 IPv4(去重、去回环、去 169.254 链路本地)
pub addrs: Vec<String>,
}
/// 枚举本机可用的 IPv4 与对应定向广播地址(网段广播,prefix<32 才有)。
///
/// 失败时返回空(beacon 退化为只发 255.255.255.255,不阻断启动)。
#[cfg(windows)]
pub fn ipv4_broadcast_pairs() -> Vec<(Ipv4Addr, Ipv4Addr)> {
use windows::Win32::NetworkManagement::IpHelper::{
GAA_FLAG_INCLUDE_PREFIX, GAA_FLAG_SKIP_ANYCAST, GAA_FLAG_SKIP_DNS_SERVER,
GAA_FLAG_SKIP_MULTICAST, GetAdaptersAddresses, IP_ADAPTER_ADDRESSES_LH,
IP_ADAPTER_UNICAST_ADDRESS_LH,
};
use windows::Win32::Networking::WinSock::{AF_INET, SOCKADDR_IN};
let mut out: Vec<(Ipv4Addr, Ipv4Addr)> = Vec::new();
unsafe {
let mut size: u32 = 0;
let flags = GAA_FLAG_INCLUDE_PREFIX
| GAA_FLAG_SKIP_ANYCAST
| GAA_FLAG_SKIP_MULTICAST
| GAA_FLAG_SKIP_DNS_SERVER;
// 第一次调用只探长度(返回 ERROR_BUFFER_OVERFLOW = 111)
let _ = GetAdaptersAddresses(AF_INET.0 as u32, flags, None, None, &mut size);
if size == 0 {
return out;
}
let mut buf = vec![0u8; size as usize];
let ptr = buf.as_mut_ptr() as *mut IP_ADAPTER_ADDRESSES_LH;
let ret = GetAdaptersAddresses(AF_INET.0 as u32, flags, None, Some(ptr), &mut size);
if ret != 0 {
crate::logger::log_warn(
"music-remote",
&format!("GetAdaptersAddresses 失败: {ret}(beacon 退化为受限广播)"),
);
return out;
}
let mut adapter = (*ptr).FirstUnicastAddress;
while !adapter.is_null() {
let ua: *mut IP_ADAPTER_UNICAST_ADDRESS_LH = adapter;
let sa = (*ua).Address;
let sockaddr = sa.lpSockaddr as *const SOCKADDR_IN;
if !sockaddr.is_null() {
let raw = u32::from_be((*sockaddr).sin_addr.S_un.S_addr);
let ip = Ipv4Addr::from(raw);
// 跳过回环与链路本地(APIPA)
if !ip.is_loopback() && !ip.is_link_local() {
let prefix = (*ua).OnLinkPrefixLength.min(32);
if prefix == 0 {
out.push((ip, Ipv4Addr::BROADCAST));
} else {
let mask = u32::MAX << (32 - prefix);
let bcast = Ipv4Addr::from(raw | !mask);
if bcast != ip && !bcast.is_loopback() {
out.push((ip, bcast));
} else {
out.push((ip, Ipv4Addr::BROADCAST));
}
}
}
}
adapter = (*ua).Next;
}
}
// 去重(多网卡同地址 / 多地址同广播)
let mut seen = std::collections::HashSet::new();
out.retain(|p| seen.insert(*p));
out
}
#[cfg(not(windows))]
pub fn ipv4_broadcast_pairs() -> Vec<(Ipv4Addr, Ipv4Addr)> {
Vec::new()
}
/// 取一个适合放进二维码 payload 的本机 LAN IP(首个非链路本地 IPv4)。
pub fn primary_ipv4() -> Option<Ipv4Addr> {
ipv4_broadcast_pairs()
.into_iter()
.map(|(ip, _)| ip)
.find(|ip| !ip.is_loopback() && !ip.is_link_local())
}
/// 启动 beacon 广播线程;`shutdown` 置 true 后最迟一个周期内退出。
pub fn spawn_beacon(payload: BeaconPayload, shutdown: Arc<AtomicBool>) -> JoinHandle<()> {
std::thread::Builder::new()
.name("remote-beacon".to_string())
.spawn(move || {
let sock = match UdpSocket::bind("0.0.0.0:0") {
Ok(s) => s,
Err(e) => {
crate::logger::log_error(
"music-remote",
&format!("beacon 套接字绑定失败: {e}"),
);
return;
}
};
let _ = sock.set_broadcast(true);
let json = serde_json::to_string(&payload).unwrap_or_default();
let bytes = json.as_bytes();
crate::logger::log_info(
"music-remote",
&format!(
"beacon 已启动 → :{BEACON_PORT},addrs={:?},payload={json}",
payload.addrs
),
);
while !shutdown.load(Ordering::Relaxed) {
// 受限广播(默认路由 NIC)
let _ = sock.send_to(bytes, ("255.255.255.255", BEACON_PORT));
// 各网卡定向广播(VPN/多网卡场景的保底路径)
for (_, bcast) in ipv4_broadcast_pairs() {
let _ = sock.send_to(bytes, (bcast, BEACON_PORT));
}
for _ in 0..(BEACON_INTERVAL.as_millis() / 100).max(1) {
if shutdown.load(Ordering::Relaxed) {
break;
}
std::thread::sleep(Duration::from_millis(100));
}
}
crate::logger::log_info("music-remote", "beacon 已停止");
})
.expect("创建 beacon 线程失败")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn payload_shape_matches_phone_expectation() {
let p = BeaconPayload {
service: "thing-music",
device_id: "d1".into(),
name: "Thing".into(),
port: 26124,
proto_ver: 1,
addrs: vec!["192.168.1.5".into()],
};
let json = serde_json::to_string(&p).unwrap();
// 手机端按 service 过滤、按 deviceId 去重(LFMusic §5.1)
assert!(json.contains("\"service\":\"thing-music\""));
assert!(json.contains("\"deviceId\":\"d1\""));
assert!(json.contains("\"protoVer\":1"));
assert!(json.contains("\"port\":26124"));
}
}
+828
View File
@@ -0,0 +1,828 @@
//! GSMTC 全局会话监视与控制(MUSIC_REMOTE_PLAN §3.1 / §5.1 `glsmtc.rs`)。
//!
//! # 线程模型(§3.1,实测修订版)
//!
//! - 监视跑在**专用线程**(`remote-gsmtc`):该线程首次 WinRT 调用即按 MTA 初始化,
//! `RequestAsync().get()` 等阻塞等待全部发生在本线程——既满足"`.get()` 不在主线程"
//! 的 STA 死锁约束,也不需要像 `smtc.rs` 那样把发起抛回主线程(GSMTC 不绑窗口,
//! 无 HWND 交互)。事件订阅也在本线程完成;回调从线程池触发,对象 agile,直接读写。
//! - 控制(`Try*Async.get`)由 server 在 `spawn_blocking` 里调 [`control`]。
//!
//! # 节流(§6.3)
//!
//! 事件风暴合并后**最快 1Hz** 发布 `state`;进度靠手机本地推算。例外:`Force`
//! (cmd 触发)立即发布一帧,绕过节流。语义变化(歌/状态/会话)不等节流窗口。
//!
//! # 失败策略(§3.1)
//!
//! GSMTC 任何失败只记日志;初始化失败 → `gsmtc_ok=false`,聚合切换到
//! AudioEngine + SmtcMetaCache 兜底(§5.2)。
use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use tauri::{AppHandle, Manager};
use tokio::sync::watch;
use windows::Foundation::TypedEventHandler;
use windows::Media::Control::{
CurrentSessionChangedEventArgs, GlobalSystemMediaTransportControlsSession as GsSession,
GlobalSystemMediaTransportControlsSessionManager as GsManager,
GlobalSystemMediaTransportControlsSessionMediaProperties as GsMediaProperties,
GlobalSystemMediaTransportControlsSessionPlaybackStatus as GsStatus,
MediaPropertiesChangedEventArgs, PlaybackInfoChangedEventArgs, SessionsChangedEventArgs,
TimelinePropertiesChangedEventArgs,
};
use super::proto::{
self, CanControl, CmdAction, CmdArgs, NowPlaying, PlayStatus, THING_SELF_SESSION,
};
use super::volume;
use super::CoverStore;
use crate::music::{AudioEngine, MusicManager, SmtcMetaCache};
/// 100 纳秒 ticks/秒。
const TICKS_PER_SEC: i64 = 10_000_000;
/// 位置跳变阈值(秒):超过它就补发一帧。与手机端 `rebaseProgress` 的
/// 1.5s 判定一致——发出来的跳变一定能被手机端识别为「来源已更新」。
const POSITION_JUMP_SEC: f64 = 1.5;
/// 封面读取上限(防异常大图)。
const MAX_COVER_BYTES: u32 = 10 * 1024 * 1024;
/// 监视线程消息。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MonitorMsg {
/// 事件到达(合并处理)
Change,
/// cmd 后立即发布(绕过 1Hz 节流,§6.3 例外)
Force,
/// 退出
Stop,
}
/// GSMTC 监视器句柄(RemoteManager 持有)。
pub struct GsmtcMonitor {
tx: Sender<MonitorMsg>,
handle: Mutex<Option<std::thread::JoinHandle<()>>>,
}
impl GsmtcMonitor {
#[allow(clippy::too_many_arguments)]
pub fn start(
app: AppHandle,
state_tx: Arc<watch::Sender<NowPlaying>>,
covers: Arc<CoverStore>,
gsmtc_ok: Arc<AtomicBool>,
sessions_tx: Arc<watch::Sender<Vec<proto::SessionInfo>>>,
selected: Arc<Mutex<Option<String>>>,
) -> Self {
let (tx, rx) = mpsc::channel::<MonitorMsg>();
let thread_tx = tx.clone();
let handle = std::thread::Builder::new()
.name("remote-gsmtc".to_string())
.spawn(move || {
run(
app, state_tx, covers, gsmtc_ok, sessions_tx, selected, thread_tx, rx,
)
})
.expect("创建 gsmtc 监视线程失败");
Self {
tx,
handle: Mutex::new(Some(handle)),
}
}
pub fn send(&self, msg: MonitorMsg) {
let _ = self.tx.send(msg);
}
pub fn notify_force(&self) {
self.send(MonitorMsg::Force);
}
/// 停止并等待线程退出(先 Stop 唤醒,join 最迟在下一次 500ms 节拍内完成)。
pub fn stop(&self) {
self.send(MonitorMsg::Stop);
let handle = self
.handle
.lock()
.unwrap_or_else(|e| e.into_inner())
.take();
if let Some(h) = handle {
let _ = h.join();
}
}
}
impl Drop for GsmtcMonitor {
fn drop(&mut self) {
self.send(MonitorMsg::Stop);
}
}
// ---------------------------------------------------------------------------
// 聚合(监视线程)
// ---------------------------------------------------------------------------
/// 语义指纹:不含 position/updatedAt(它们每秒都变,单独走进度窗口)。
fn fingerprint(np: &NowPlaying) -> String {
// 引用 + 元组整体 Debug:避开逐字段 format 的 Display/Debug 混用与 move 错误
format!(
"{:?}",
(
&np.session_id,
&np.source_app,
np.is_thing,
&np.title,
&np.artist,
&np.album,
&np.cover_hash,
np.status,
np.duration_sec,
&np.can_control,
np.volume,
np.muted,
)
)
}
fn run(
app: AppHandle,
state_tx: Arc<watch::Sender<NowPlaying>>,
covers: Arc<CoverStore>,
gsmtc_ok: Arc<AtomicBool>,
sessions_tx: Arc<watch::Sender<Vec<proto::SessionInfo>>>,
selected: Arc<Mutex<Option<String>>>,
tx: Sender<MonitorMsg>,
rx: Receiver<MonitorMsg>,
) {
// 首次 WinRT 调用在此线程自动按 MTA 初始化(见模块注释)
// RequestAsync() → Result<IAsyncOperation<_>>;外层 Result 与异步 get() 分两步
let manager = GsManager::RequestAsync().and_then(|op| op.get());
match &manager {
Ok(_) => {
gsmtc_ok.store(true, Ordering::Relaxed);
crate::logger::log_info("music-remote", "GSMTC 已初始化(专用线程 MTA)");
}
Err(e) => {
gsmtc_ok.store(false, Ordering::Relaxed);
crate::logger::log_error(
"music-remote",
&format!("GSMTC 初始化失败,远程查看/控制降级为「仅 Thing 自身」: {e}"),
);
}
}
// 事件订阅:任一变更 → Change(合并节流在下方发布逻辑里)
if let Ok(m) = &manager {
let t = tx.clone();
let _ = m.CurrentSessionChanged(
&TypedEventHandler::<GsManager, CurrentSessionChangedEventArgs>::new(move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
}),
);
let t = tx.clone();
let _ = m.SessionsChanged(
&TypedEventHandler::<GsManager, SessionsChangedEventArgs>::new(move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
}),
);
// 说明:MediaProperties/Timeline/PlaybackInfo 是 **Session 级**事件(挂在每条会话上,
// 需随会话变化反复订阅/退订)。P0 简化为不订阅——聚合本身以 500ms 节拍轮询,
// 语义变化最多延迟 ~500ms 上屏(发布规则见下),1Hz 进度窗口不受影响;
// 会话级事件的精细化订阅列入 P1(计划 §7)。
}
let mut last_publish: Option<Instant> = None;
let mut last_fp = String::new();
// 上次**发布**时的位置:位置不进语义指纹(每秒都变),单独用来识别跳变
let mut last_pos: Option<f64> = None;
// 封面快捷缓存:coverKey → hash(避免同曲反复读缩略图;字节在 CoverStore)
let mut cover_local: HashMap<String, String> = HashMap::new();
// AUMID → 显示名缓存(注册表友好名,P1 §7)
let mut name_cache: HashMap<String, String> = HashMap::new();
// 会话列表指纹(变化才推 sessions 消息)
let mut last_sessions_fp = String::new();
// 当前目标会话的事件订阅(P1 §7 会话级事件:随目标切换订阅/退订)
let mut subs: Option<SessionSubs> = None;
let mut last_sub_aumid = String::new();
loop {
// 收一轮消息(风暴合并)
let mut force = false;
let mut running = true;
match rx.recv_timeout(Duration::from_millis(500)) {
Ok(MonitorMsg::Stop) => running = false,
Ok(MonitorMsg::Force) => force = true,
Ok(MonitorMsg::Change) => {}
Err(RecvTimeoutError::Timeout) => {}
Err(RecvTimeoutError::Disconnected) => running = false,
}
while running {
match rx.try_recv() {
Ok(MonitorMsg::Stop) => {
running = false;
break;
}
Ok(MonitorMsg::Force) => force = true,
Ok(MonitorMsg::Change) => {}
Err(_) => break,
}
}
if !running {
break;
}
// 设置读取:remote_device_id(MusicManager 500ms 缓存,开销可忽略)
let device_id = app
.try_state::<MusicManager>()
.map(|m| m.load_settings().remote_device_id)
.unwrap_or_default();
// 目标会话:手机选中覆盖优先,否则系统 current(P1 多会话切换;
// WinRT 无 SetCurrentSession,选中是 Thing 侧覆盖而非改系统判定)
let (target, needs_clear) = match &manager {
Ok(m) => {
let sel = selected
.lock()
.map(|g| g.clone())
.unwrap_or_default();
pick_target(m, sel.as_deref())
}
Err(_) => (None, false),
};
if needs_clear {
if let Ok(mut s) = selected.lock() {
s.take();
}
}
// 会话级事件订阅跟随目标(P1 §7:Media/Timeline/PlaybackInfo 随会话退订换绑)
if manager.is_ok() {
let aumid = target
.as_ref()
.and_then(|s| s.SourceAppUserModelId().ok())
.map(|h| h.to_string())
.unwrap_or_default();
if aumid != last_sub_aumid {
if let Some(old) = subs.take() {
old.remove_all();
}
if let Some(t) = &target {
subs = Some(SessionSubs::subscribe(t, &tx));
}
last_sub_aumid = aumid;
}
}
// 系统主音量轮询(P1 §7;500ms 一次,端点不可用时 volume=None)
let (vol, muted) = volume::read().map(|(v, m)| (Some(v), m)).unwrap_or((None, false));
let mut np = if manager.is_err() {
aggregate_fallback(&app, &device_id)
} else if let Some(sess) = &target {
aggregate_session(&app, sess, &device_id, &covers, &mut cover_local, &mut name_cache)
} else {
NowPlaying::stopped(&device_id)
};
np.volume = vol;
np.muted = muted;
// 会话列表(变化才推;连接时 watch 快照兜底)
if let Ok(m) = &manager {
let list = build_sessions(m, np.session_id.as_str(), &mut name_cache);
let fp_s = format!("{:?}", list);
if fp_s != last_sessions_fp {
last_sessions_fp = fp_s;
sessions_tx.send_replace(list);
}
}
let fp = fingerprint(&np);
let semantic = fp != last_fp;
let playing = np.status == PlayStatus::Playing;
let progress_due = last_publish
.map(|t| t.elapsed() >= Duration::from_secs(1))
.unwrap_or(true);
// 位置跳变(seek)单独发帧:`position` 不进指纹,暂停态又没有 1Hz 进度帧,
// 不补这一帧的话,手机端刚拖好的位置永远等不到来源确认
// (保持窗口到期后只能回退到旧位置,表现为「先保持再跳回去」)
let position_jump = last_pos
.map(|p| (np.position_sec - p).abs() > POSITION_JUMP_SEC)
.unwrap_or(false);
if force || semantic || position_jump || (playing && progress_due) {
last_publish = Some(Instant::now());
last_fp = fp;
last_pos = Some(np.position_sec);
// watch:无接收者时 send_replace 仍更新值(新客户端从 borrow 拿快照)
state_tx.send_replace(np);
}
}
if let Some(s) = subs.take() {
s.remove_all();
}
crate::logger::log_info("music-remote", "GSMTC 监视线程已退出");
}
/// 把目标会话聚合成 `NowPlaying`(§5.2 主路径;目标由 [`pick_target`] 选定)。
fn aggregate_session(
app: &AppHandle,
session: &GsSession,
device_id: &str,
covers: &CoverStore,
cover_local: &mut HashMap<String, String>,
name_cache: &mut HashMap<String, String>,
) -> NowPlaying {
let aumid = session
.SourceAppUserModelId()
.map(|h| h.to_string())
.unwrap_or_default();
let is_thing = proto::is_thing_aumid(&aumid);
// 元数据(§6.2 缩略图)
let props = session.TryGetMediaPropertiesAsync().and_then(|op| op.get());
let (title, artist, album) = match &props {
Ok(p) => (
p.Title().map(|h| h.to_string()).unwrap_or_default(),
p.Artist().map(|h| h.to_string()).unwrap_or_default(),
p.AlbumTitle().map(|h| h.to_string()).unwrap_or_default(),
),
Err(_) => (String::new(), String::new(), String::new()),
};
let cover_hash = props.as_ref().ok().and_then(|p| {
let key = format!("{aumid}|{title}|{album}");
cover_for(p, &key, covers, cover_local)
});
// 播放状态与能力位
let info = session.GetPlaybackInfo();
let status = match info.as_ref().ok().and_then(|i| i.PlaybackStatus().ok()) {
Some(GsStatus::Playing) => PlayStatus::Playing,
Some(GsStatus::Paused) => PlayStatus::Paused,
_ => PlayStatus::Stopped,
};
let can = match info.as_ref().ok().and_then(|i| i.Controls().ok()) {
// Thing 自身会话:控制走前端事件链直通(play/pause/next/prev/seek 全部可用),
// 不看 SMTC 的能力位——系统面板那套 IsXxxEnabled 里没有 seek 位,
// 照抄会把手机端的进度条锁成只读(seek 实际由 AudioEngine 直接处理)
Some(_) if is_thing => CanControl {
play: true,
pause: true,
next: true,
prev: true,
seek: true,
},
Some(c) => CanControl {
play: c.IsPlayEnabled().unwrap_or(false),
pause: c.IsPauseEnabled().unwrap_or(false),
next: c.IsNextEnabled().unwrap_or(false),
prev: c.IsPreviousEnabled().unwrap_or(false),
// WinRT 无 IsSeekEnabled,seek 能力位叫 IsPlaybackPositionEnabled
seek: c.IsPlaybackPositionEnabled().unwrap_or(false),
},
None if is_thing => CanControl {
play: true,
pause: true,
next: true,
prev: true,
seek: true,
},
None => CanControl {
play: false,
pause: false,
next: false,
prev: false,
seek: false,
},
};
// PlaybackRate 是 IReference<f64>(可空)→ Value() 解引用
let playback_rate = info
.as_ref()
.ok()
.and_then(|i| i.PlaybackRate().ok())
.and_then(|r| r.Value().ok())
.filter(|r| r.is_finite() && *r > 0.0)
.unwrap_or(1.0);
// 时间轴(§6.4:位置基准用 LastUpdatedTime)
let (position_sec, duration_sec, position_updated_at_ms) = match session.GetTimelineProperties()
{
Ok(tl) => {
let pos = tl
.Position()
.map(|t| t.Duration as f64 / TICKS_PER_SEC as f64)
.unwrap_or(0.0);
let dur = tl
.EndTime()
.map(|t| t.Duration as f64 / TICKS_PER_SEC as f64)
.unwrap_or(0.0);
// `LastUpdatedTime = 0` = 来源从未上报过时间轴(bilibili PC 实测:
// position=0 / EndTime=0 / LastUpdatedTime=0)。换算出的负值同样没有意义,
// 一律归 0 作「无进度基准」哨兵,手机端据此停掉进度推算(否则每秒一帧
// 从 0 起算,进度条原地抽搐)。
let updated = tl
.LastUpdatedTime()
.map(|d| proto::winrt_ticks_to_unix_ms(d.UniversalTime))
.unwrap_or(0);
(pos.max(0.0), dur.max(0.0), updated.max(0))
}
// 取不到时间轴 = 没有可用基准,不能拿本机时间伪装成"刚更新过"
Err(_) => (0.0, 0.0, 0),
};
// Thing 自身会话:位置改用 AudioEngine 快照。SMTC 那份由前端按 1s 节流上报、
// 暂停态甚至不刷新,手机端拖完 seek 会一直等不到「来源已到新位置」的确认,
// 保持窗口到期后只能回退到旧位置。引擎快照是逐次读取的权威值,seek 后立即反映。
let (position_sec, position_updated_at_ms) = if is_thing {
let engine_pos = app.try_state::<AudioEngine>().and_then(|e| {
let st = e.state();
st.active.then_some(st.position_sec)
});
match engine_pos {
Some(p) => (p.max(0.0), now_unix_ms()),
None => (position_sec, position_updated_at_ms), // 引擎无会话:退回 SMTC 值
}
} else {
(position_sec, position_updated_at_ms)
};
NowPlaying {
session_id: proto::session_key(&aumid),
source_app: friendly_name(&aumid, name_cache),
is_thing,
title,
artist,
album,
cover_hash,
status,
duration_sec,
position_sec,
position_updated_at_ms,
playback_rate,
can_control: can,
volume: None,
muted: false,
device_id: device_id.to_string(),
}
}
/// 读取会话缩略图 → 存 CoverStore → 返回 hash(§6.2:WS 只带 hash)。
fn cover_for(
props: &GsMediaProperties,
key: &str,
covers: &CoverStore,
local: &mut HashMap<String, String>,
) -> Option<String> {
if let Some(h) = local.get(key) {
return Some(h.clone());
}
// 无缩略图(null → Err)直接返回 None;同 key 不重试(记空串占位)
let reference = match props.Thumbnail() {
Ok(r) => r,
Err(_) => {
local.insert(key.to_string(), String::new());
return None;
}
};
let bytes = read_thumb(&reference)?;
let hash = covers.put(&bytes)?;
// 快捷缓存防膨胀(同曲重读的代价可接受)
if local.len() > 128 {
local.clear();
}
local.insert(key.to_string(), hash.clone());
Some(hash)
}
/// `IRandomAccessStreamReference` → 字节(DataReader 路径,无需 Cryptography feature)。
fn read_thumb(reference: &windows::Storage::Streams::IRandomAccessStreamReference) -> Option<Vec<u8>> {
use windows::Storage::Streams::DataReader;
let stream = reference.OpenReadAsync().ok()?.get().ok()?;
let size = stream.Size().ok()? as u32;
if size == 0 || size > MAX_COVER_BYTES {
return None;
}
let reader = DataReader::CreateDataReader(&stream).ok()?;
reader.LoadAsync(size).ok()?.get().ok()?;
let mut buf = vec![0u8; size as usize];
reader.ReadBytes(&mut buf).ok()?;
Some(buf)
}
/// 兜底聚合(§5.2:GSMTC 不可用时):AudioEngine 状态 + 前端已推送的 SMTC 元数据。
fn aggregate_fallback(app: &AppHandle, device_id: &str) -> NowPlaying {
let engine = match app.try_state::<AudioEngine>() {
Some(e) => e,
None => return NowPlaying::stopped(device_id),
};
let st = engine.state();
if !st.active {
return NowPlaying::stopped(device_id);
}
let meta = app
.try_state::<SmtcMetaCache>()
.map(|c| c.0.lock().unwrap_or_else(|e| e.into_inner()).clone())
.unwrap_or_default();
NowPlaying {
session_id: THING_SELF_SESSION.to_string(),
source_app: proto::source_display(proto::THING_AUMID),
is_thing: true,
title: meta.title,
artist: meta.artist,
album: meta.album,
cover_hash: None,
status: if st.playing {
PlayStatus::Playing
} else {
PlayStatus::Paused
},
position_sec: st.position_sec,
position_updated_at_ms: now_unix_ms(),
playback_rate: 1.0,
can_control: CanControl {
play: true,
pause: true,
next: true,
prev: true,
seek: true,
},
device_id: device_id.to_string(),
..NowPlaying::default()
}
}
fn now_unix_ms() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis() as i64)
.unwrap_or(0)
}
// ---------------------------------------------------------------------------
// 会话选择 / 列表 / 事件订阅 / 友好名(P1 §7)
// ---------------------------------------------------------------------------
/// 选定目标会话:`selected` 命中则用之;否则系统 current。
/// 返回 `(目标, 是否需要清除选中)`——选中项已消失时回退 current 并标记清除。
/// (WinRT **没有** SetCurrentSession:选中是 Thing 侧覆盖,不改系统判定。)
fn pick_target(manager: &GsManager, selected: Option<&str>) -> (Option<GsSession>, bool) {
if let Some(sid) = selected.filter(|s| !s.is_empty()) {
let mut found: Option<GsSession> = None;
if let Ok(list) = manager.GetSessions() {
for i in 0..list.Size().unwrap_or(0) {
if let Ok(s) = list.GetAt(i) {
let key = s
.SourceAppUserModelId()
.ok()
.map(|h| proto::session_key(&h.to_string()));
if key.as_deref() == Some(sid) {
found = Some(s);
break;
}
}
}
}
return match found {
Some(s) => (Some(s), false),
None => (manager.GetCurrentSession().ok(), true),
};
}
(manager.GetCurrentSession().ok(), false)
}
/// 枚举全部会话为手机端列表(`is_current` = 是否当前展示目标)。
fn build_sessions(
manager: &GsManager,
current_key: &str,
name_cache: &mut HashMap<String, String>,
) -> Vec<proto::SessionInfo> {
let Ok(list) = manager.GetSessions() else {
return Vec::new();
};
let mut out = Vec::new();
for i in 0..list.Size().unwrap_or(0) {
let Ok(s) = list.GetAt(i) else { continue };
let aumid = s
.SourceAppUserModelId()
.map(|h| h.to_string())
.unwrap_or_default();
let key = proto::session_key(&aumid);
let (title, artist) = match s.TryGetMediaPropertiesAsync().and_then(|op| op.get()) {
Ok(p) => (
p.Title().map(|h| h.to_string()).unwrap_or_default(),
p.Artist().map(|h| h.to_string()).unwrap_or_default(),
),
Err(_) => (String::new(), String::new()),
};
let status = match s.GetPlaybackInfo().and_then(|i| i.PlaybackStatus()) {
Ok(GsStatus::Playing) => PlayStatus::Playing,
Ok(GsStatus::Paused) => PlayStatus::Paused,
_ => PlayStatus::Stopped,
};
out.push(proto::SessionInfo {
is_current: key == current_key,
session_id: key,
source_app: friendly_name(&aumid, name_cache),
title,
artist,
status,
is_thing: proto::is_thing_aumid(&aumid),
});
}
out
}
/// 目标会话的三个事件订阅(P1 §7:随目标切换退订/换绑,唤醒聚合循环)。
struct SessionSubs {
session: GsSession,
tokens: Vec<(SubKind, windows::Foundation::EventRegistrationToken)>,
}
enum SubKind {
Props,
Timeline,
Info,
}
impl SessionSubs {
fn subscribe(sess: &GsSession, tx: &Sender<MonitorMsg>) -> Self {
let mut tokens = Vec::new();
// 三个事件的 args 类型各不相同,逐个构造 handler(不能复用闭包)
{
let t = tx.clone();
let h = TypedEventHandler::<GsSession, MediaPropertiesChangedEventArgs>::new(
move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
},
);
if let Ok(tok) = sess.MediaPropertiesChanged(&h) {
tokens.push((SubKind::Props, tok));
}
}
{
let t = tx.clone();
let h = TypedEventHandler::<GsSession, TimelinePropertiesChangedEventArgs>::new(
move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
},
);
if let Ok(tok) = sess.TimelinePropertiesChanged(&h) {
tokens.push((SubKind::Timeline, tok));
}
}
{
let t = tx.clone();
let h = TypedEventHandler::<GsSession, PlaybackInfoChangedEventArgs>::new(
move |_, _| {
let _ = t.send(MonitorMsg::Change);
Ok(())
},
);
if let Ok(tok) = sess.PlaybackInfoChanged(&h) {
tokens.push((SubKind::Info, tok));
}
}
Self {
session: sess.clone(),
tokens,
}
}
fn remove_all(self) {
for (kind, tok) in self.tokens {
let r = match kind {
SubKind::Props => self.session.RemoveMediaPropertiesChanged(tok),
SubKind::Timeline => self.session.RemoveTimelinePropertiesChanged(tok),
SubKind::Info => self.session.RemovePlaybackInfoChanged(tok),
};
if let Err(e) = r {
crate::logger::log_warn("music-remote", &format!("退订会话事件失败: {e}"));
}
}
}
}
/// AUMID → 显示名:注册表友好名(`HKCU\\Software\\Classes\\AppUserModelId\\<aumid>`)
/// 缓存优先,查不到退回 AUMID 简化段(§6.7 P1)。
fn friendly_name(aumid: &str, cache: &mut HashMap<String, String>) -> String {
if let Some(v) = cache.get(aumid) {
return v.clone();
}
let name = if proto::is_thing_aumid(aumid) {
"Thing".to_string()
} else {
registry_display_name(aumid).unwrap_or_else(|| proto::source_display(aumid))
};
if cache.len() > 128 {
cache.clear();
}
cache.insert(aumid.to_string(), name.clone());
name
}
fn registry_display_name(aumid: &str) -> Option<String> {
// 路径形 AUMID(含反斜杠)无法作注册表单键名;空串跳过
if aumid.is_empty() || aumid.contains('\\') {
return None;
}
use winreg::RegKey;
use winreg::enums::HKEY_CURRENT_USER;
let key = RegKey::predef(HKEY_CURRENT_USER)
.open_subkey(format!(r"Software\Classes\AppUserModelId\{aumid}"))
.ok()?;
key.get_value::<String, _>("DisplayName")
.ok()
.filter(|s| !s.trim().is_empty())
}
// ---------------------------------------------------------------------------
// 控制(server 在 spawn_blocking 里调用)
// ---------------------------------------------------------------------------
/// 对指定会话执行控制动作(§3.1:统一走 GSMTC `Try*Async`)。
///
/// **阻塞**(`.get()` 等待 WinRT async):调用方必须在 `spawn_blocking` / 专用线程。
/// `session_id` 为 [`proto::NowPlaying::session_id`](控制"手机上正在显示的那条")。
pub fn control(session_id: &str, action: CmdAction, args: Option<CmdArgs>) -> Result<(), String> {
let manager = GsManager::RequestAsync()
.and_then(|op| op.get())
.map_err(|e| format!("GSMTC 不可用: {e}"))?;
let session = find_session(&manager, session_id)?;
// toggle 需要先读当前状态
let playing = matches!(
session.GetPlaybackInfo().and_then(|i| i.PlaybackStatus()),
Ok(GsStatus::Playing)
);
let op = match action {
CmdAction::Play => session.TryPlayAsync().map_err(err_of)?,
CmdAction::Pause => session.TryPauseAsync().map_err(err_of)?,
CmdAction::Toggle => {
if playing {
session.TryPauseAsync().map_err(err_of)?
} else {
session.TryPlayAsync().map_err(err_of)?
}
}
CmdAction::Next => session.TrySkipNextAsync().map_err(err_of)?,
CmdAction::Prev => session.TrySkipPreviousAsync().map_err(err_of)?,
CmdAction::Stop => session.TryStopAsync().map_err(err_of)?,
CmdAction::Seek => {
let pos = args
.as_ref()
.map(|a| a.pos_sec)
.ok_or_else(|| "seek 缺少 args.posSec".to_string())?;
let v = if pos.is_finite() && pos > 0.0 {
pos
} else {
0.0
};
// WinRT 签名是 INT64(100ns ticks),不是 TimeSpan
session
.TryChangePlaybackPositionAsync((v * TICKS_PER_SEC as f64) as i64)
.map_err(err_of)?
}
// Volume/Select/Jump 由 server 直接处理(音量走 IAudioEndpointVolume、选中走 Thing 侧覆盖、
// 选歌走前端事件链),不会路由到这里;列全仅为 match 穷尽
CmdAction::Volume | CmdAction::Select | CmdAction::Jump => {
return Err("volume/select/jump 不走 GSMTC 控制路径".into())
}
};
// 阻塞等待完成(语义 = 指令已派发,§4.2 cmd-ack)
let _ = op.get().map_err(err_of)?;
Ok(())
}
fn err_of<E: std::fmt::Display>(e: E) -> String {
format!("{e}")
}
/// 按 sessionId 找会话(`thing.self` → AUMID 匹配;否则 AUMID 全等;回退 current)。
fn find_session(manager: &GsManager, session_id: &str) -> Result<GsSession, String> {
let sessions = manager.GetSessions().map_err(err_of)?;
let n = sessions.Size().map_err(err_of)?;
for i in 0..n {
let s = sessions.GetAt(i).map_err(err_of)?;
let aumid = s
.SourceAppUserModelId()
.map(|h| h.to_string())
.unwrap_or_default();
if proto::session_key(&aumid) == session_id {
return Ok(s);
}
}
manager
.GetCurrentSession()
.map_err(|_| format!("目标会话不存在: {session_id}"))
}
+756
View File
@@ -0,0 +1,756 @@
//! 手机遥控子系统(MUSIC_REMOTE_PLAN §5.1)。
//!
//! [RemoteManager] 是本子系统的唯一状态容器(**平级 manage**,不塞进 MusicManager,
//! 见计划 §5.1):服务生命周期、配对会话、封面缓存、鉴权限速、在线设备、
//! 聚合状态(`watch<NowPlaying>`)。
//!
//! | 文件 | 职责 |
//! |---|---|
//! | [`proto`] | NowPlaying / WS 消息类型(§4)+ 单测 |
//! | [`discovery`] | UDP beacon(§3.3,含各网卡定向广播) |
//! | [`pairing`] | 配对码、设备表、token、限速(§3.4) |
//! | [`glsmtc`] | GSMTC 监视/聚合/封面 LRU/节流 + Try*Async 控制(§3.1) |
//! | [`server`] | axum HTTP+WS、鉴权、广播、心跳(§3.2 / §4.2) |
//!
//! 设置字段(`MusicSettings`,settings.json):`remote_enabled` / `remote_port` /
//! `remote_device_id` / `remote_devices`——设备**元数据**落 settings,**token** 入
//! 系统凭据管理器(键名 `music-remote-token-{id}`,§3.4-3)。
mod discovery;
mod glsmtc;
mod pairing;
mod proto;
mod server;
mod volume;
pub use pairing::RemoteDeviceMeta;
pub use proto::{NowPlaying, PROTO_VER};
/// 手机选歌 → 前端播放器的事件名(载荷 = 队列绝对下标)。
pub const REMOTE_JUMP_EVENT: &str = "music-remote-jump";
use std::collections::HashMap;
use std::hash::{Hash, Hasher};
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::thread::JoinHandle;
use serde::{Deserialize, Serialize};
use specta::Type;
use tauri::{AppHandle, Manager};
use tokio::sync::watch;
use discovery::BeaconPayload;
use glsmtc::GsmtcMonitor;
use pairing::PairingSession;
use super::MusicManager;
// ---------------------------------------------------------------------------
// 封面缓存(§6.2:内存 LRU,上限 ~20 张;/cover/:hash 由此供给)
// ---------------------------------------------------------------------------
struct CoverEntry {
bytes: Vec<u8>,
seq: u64,
}
/// 封面字节 LRU(内容哈希为键;seq 兼作 LRU 计数)。
/// P1 §7:写透到磁盘目录(`{app_data}/remote_covers`),Thing 重启后手机仍能拉到封面。
pub struct CoverStore {
map: Mutex<HashMap<String, CoverEntry>>,
seq: AtomicU64,
/// 磁盘目录(None = 仅内存;start() 时 attach)
dir: Mutex<Option<std::path::PathBuf>>,
}
impl CoverStore {
pub fn new() -> Self {
Self {
map: Mutex::new(HashMap::new()),
seq: AtomicU64::new(0),
dir: Mutex::new(None),
}
}
/// 挂载持久化目录(服务启动时调用;创建目录,失败只记日志)。
pub fn attach_dir(&self, dir: std::path::PathBuf) {
if let Err(e) = std::fs::create_dir_all(&dir) {
crate::logger::log_warn(
"music-remote",
&format!("封面持久化目录创建失败(仅内存缓存): {e}"),
);
return;
}
if let Ok(mut g) = self.dir.lock() {
*g = Some(dir);
}
}
fn dir_opt(&self) -> Option<std::path::PathBuf> {
self.dir.lock().ok().and_then(|g| g.clone())
}
/// 存入封面,返回内容哈希(同内容同哈希);超限淘汰最旧。
pub fn put(&self, bytes: &[u8]) -> Option<String> {
if bytes.is_empty() || bytes.len() > 10 * 1024 * 1024 {
return None;
}
let mut hasher = std::collections::hash_map::DefaultHasher::new();
bytes.hash(&mut hasher);
let hash = format!("{:016x}", hasher.finish());
let mut map = self.map.lock().unwrap_or_else(|e| e.into_inner());
map.insert(
hash.clone(),
CoverEntry {
bytes: bytes.to_vec(),
seq: self.seq.fetch_add(1, Ordering::Relaxed),
},
);
while map.len() > 20 {
let oldest = map
.iter()
.min_by_key(|(_, e)| e.seq)
.map(|(k, _)| k.clone());
match oldest {
Some(k) => {
map.remove(&k);
}
None => break,
}
}
drop(map);
// 写透磁盘(尽力而为;失败不影响内存路径)
if let Some(dir) = self.dir_opt() {
let path = dir.join(format!("{hash}.img"));
if std::fs::write(&path, bytes).is_ok() {
// 目录同样限 20 张:按修改时间淘汰最旧
if let Ok(rd) = std::fs::read_dir(&dir) {
let mut files: Vec<(std::time::SystemTime, std::path::PathBuf)> = rd
.flatten()
.filter_map(|e| {
let p = e.path();
if p.extension().and_then(|x| x.to_str()) != Some("img") {
return None;
}
let t = e.metadata().ok()?.modified().ok()?;
Some((t, p))
})
.collect();
if files.len() > 20 {
files.sort_by_key(|(t, _)| *t);
for (_, p) in files.iter().take(files.len() - 20) {
let _ = std::fs::remove_file(p);
}
}
}
}
}
Some(hash)
}
/// 读取(内存 → 磁盘回源;命中即刷新 LRU 序号)。
pub fn get(&self, hash: &str) -> Option<Vec<u8>> {
{
let mut map = self.map.lock().unwrap_or_else(|e| e.into_inner());
let seq = self.seq.fetch_add(1, Ordering::Relaxed);
if let Some(entry) = map.get_mut(hash) {
entry.seq = seq;
return Some(entry.bytes.clone());
}
}
// 磁盘回源(Thing 重启 / 冷缓存)
let dir = self.dir_opt()?;
let bytes = std::fs::read(dir.join(format!("{hash}.img"))).ok()?;
let mut map = self.map.lock().unwrap_or_else(|e| e.into_inner());
map.insert(
hash.to_string(),
CoverEntry {
bytes: bytes.clone(),
seq: self.seq.fetch_add(1, Ordering::Relaxed),
},
);
while map.len() > 20 {
let oldest = map
.iter()
.min_by_key(|(_, e)| e.seq)
.map(|(k, _)| k.clone());
match oldest {
Some(k) => {
map.remove(&k);
}
None => break,
}
}
Some(bytes)
}
}
impl Default for CoverStore {
fn default() -> Self {
Self::new()
}
}
// ---------------------------------------------------------------------------
// 对外状态视图(命令返回值)
// ---------------------------------------------------------------------------
/// 远程配置(§5.1 命令 `remote_get_config` / `remote_set_enabled`)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteConfig {
/// 开关(持久化)
pub enabled: bool,
/// 期望端口(0 = 默认 26124 起自动探测)
pub port: u16,
/// 服务是否在运行
pub running: bool,
/// 实际监听端口(未运行为 0)
pub running_port: u16,
/// 本机标识(beacon / NowPlaying.deviceId 同源)
pub device_id: String,
}
/// 进行中的配对信息(二维码 payload 见计划 §3.3 扫码行)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemotePairingInfo {
pub code: String,
/// `thingmusic://connect?ip=…&port=…&code=…`
pub qr_payload: String,
pub seconds_left: u64,
}
/// 设备视图(settings 元数据 + 在线态)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteDeviceView {
pub id: String,
pub name: String,
pub last_connected_ms: i64,
pub online: bool,
}
/// 服务状态(`remote_status`)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteStatus {
pub running: bool,
pub port: u16,
pub online: Vec<RemoteDeviceView>,
pub pairing: Option<RemotePairingInfo>,
}
// ---------------------------------------------------------------------------
// RemoteManager
// ---------------------------------------------------------------------------
/// 服务内部状态(start/stop 独占)。
struct Inner {
running: bool,
port: u16,
server_task: Option<tokio::task::JoinHandle<()>>,
beacon_stop: Option<Arc<AtomicBool>>,
beacon_handle: Option<JoinHandle<()>>,
pairing: Option<PairingSession>,
}
impl Default for Inner {
fn default() -> Self {
Self {
running: false,
port: 0,
server_task: None,
beacon_stop: None,
beacon_handle: None,
pairing: None,
}
}
}
pub struct RemoteManager {
/// 聚合状态(监视线程写、WS/REST 读)
pub(crate) state_tx: Arc<watch::Sender<NowPlaying>>,
/// 会话列表(P1 多会话切换;监视线程写、WS 读)
pub(crate) sessions_tx: Arc<watch::Sender<Vec<proto::SessionInfo>>>,
/// Thing 本机播放队列(前端 `remote_publish_queue` 写、WS 读)
pub(crate) queue_tx: Arc<watch::Sender<proto::QueueSnapshot>>,
/// 手机选中的目标会话覆盖(None = 跟随系统 current;WinRT 无 SetCurrentSession)
pub(crate) selected: Arc<Mutex<Option<String>>>,
/// 封面 LRU(glsmtc 写、/cover 读)
pub(crate) covers: Arc<CoverStore>,
/// hello / /pair 限速(§3.4-4)
pub(crate) auth: Arc<pairing::FailTracker>,
/// GSMTC 是否可用(false → 控制走前端事件链兜底,§5.2)
pub(crate) gsmtc_ok: Arc<AtomicBool>,
/// 服务停止信号(每个 WS 连接订阅一份)
shutdown_tx: watch::Sender<bool>,
online: Mutex<std::collections::HashSet<String>>,
monitor: Mutex<Option<GsmtcMonitor>>,
inner: Mutex<Inner>,
}
impl RemoteManager {
pub fn new() -> Self {
let (state_tx, _) = watch::channel(NowPlaying::default());
let (sessions_tx, _) = watch::channel(Vec::new());
let (queue_tx, _) = watch::channel(proto::QueueSnapshot::default());
let (shutdown_tx, _) = watch::channel(false);
Self {
state_tx: Arc::new(state_tx),
sessions_tx: Arc::new(sessions_tx),
queue_tx: Arc::new(queue_tx),
selected: Arc::new(Mutex::new(None)),
covers: Arc::new(CoverStore::new()),
auth: Arc::new(pairing::FailTracker::default()),
gsmtc_ok: Arc::new(AtomicBool::new(false)),
shutdown_tx,
online: Mutex::new(std::collections::HashSet::new()),
monitor: Mutex::new(None),
inner: Mutex::new(Inner::default()),
}
}
/// 当前聚合状态快照。
pub fn now_playing(&self) -> NowPlaying {
self.state_tx.borrow().clone()
}
/// 会话列表快照(WS 连接建立时下发)。
pub fn sessions_snapshot(&self) -> Vec<proto::SessionInfo> {
self.sessions_tx.borrow().clone()
}
/// 订阅会话列表变更(每个 WS 连接一份)。
pub fn sessions_rx(&self) -> watch::Receiver<Vec<proto::SessionInfo>> {
self.sessions_tx.subscribe()
}
/// 队列快照(WS 连接建立时下发;Thing 本机播放的队列)。
pub fn queue_snapshot(&self) -> proto::QueueSnapshot {
self.queue_tx.borrow().clone()
}
/// 订阅队列变更(每个 WS 连接一份)。
pub fn queue_rx(&self) -> watch::Receiver<proto::QueueSnapshot> {
self.queue_tx.subscribe()
}
/// 前端发布队列快照;内容没变时不推送(避免播放中反复触发 WS 帧)。
pub fn set_queue(&self, snapshot: proto::QueueSnapshot) {
let unchanged = *self.queue_tx.borrow() == snapshot;
if unchanged {
return;
}
self.queue_tx.send_replace(snapshot);
}
/// 设置目标会话覆盖;空串 = 清除(跟随系统 current)。P1 多会话切换。
pub fn set_selected(&self, session_id: &str) {
let mut g = self.selected.lock().unwrap_or_else(|e| e.into_inner());
*g = if session_id.trim().is_empty() {
None
} else {
Some(session_id.to_string())
};
}
/// cmd 后立即推一帧(§6.3 例外)。
pub fn notify_state_force(&self) {
let guard = self.monitor.lock().unwrap_or_else(|e| e.into_inner());
if let Some(m) = guard.as_ref() {
m.notify_force();
}
}
pub fn is_running(&self) -> bool {
self.inner
.lock()
.map(|g| g.running)
.unwrap_or(false)
}
pub fn running_port(&self) -> u16 {
self.inner.lock().map(|g| g.port).unwrap_or(0)
}
pub fn shutdown_rx(&self) -> watch::Receiver<bool> {
self.shutdown_tx.subscribe()
}
pub fn mark_online(&self, id: &str, on: bool) {
if let Ok(mut set) = self.online.lock() {
if on {
set.insert(id.to_string());
} else {
set.remove(id);
}
}
}
fn online_ids(&self) -> std::collections::HashSet<String> {
self.online
.lock()
.map(|s| s.clone())
.unwrap_or_default()
}
// ---------- 配对(§3.4) ----------
/// 开始配对:生成 6 位码(5 分钟有效、一次性)。服务未运行时拒绝(二维码需要端口)。
pub fn start_pairing(&self) -> Result<RemotePairingInfo, String> {
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
if !inner.running {
return Err("远程服务未启动,请先开启「手机互联」".into());
}
let session = PairingSession::generate();
// 联调辅助:配对码写入本地日志(屏幕同样可见;日志仅本机)
crate::logger::log_info(
"music-remote",
format!("配对码已生成: {}(5 分钟内有效)", session.code).as_str(),
);
let info = Self::pairing_info_of(&session, inner.port);
inner.pairing = Some(session);
Ok(info)
}
pub fn cancel_pairing(&self) {
if let Ok(mut inner) = self.inner.lock() {
inner.pairing = None;
}
}
pub fn pairing_info(&self) -> Option<RemotePairingInfo> {
let inner = self.inner.lock().ok()?;
let s = inner.pairing.as_ref()?;
if s.is_expired() {
return None;
}
Some(Self::pairing_info_of(s, inner.port))
}
fn pairing_info_of(s: &PairingSession, port: u16) -> RemotePairingInfo {
let ip = discovery::primary_ipv4()
.map(|i| i.to_string())
.unwrap_or_default();
RemotePairingInfo {
code: s.code.clone(),
qr_payload: format!("thingmusic://connect?ip={ip}&port={port}&code={}", s.code),
seconds_left: s.seconds_left(),
}
}
/// 校验并消费配对码(一次性);成功返回 Ok 并清除会话。
pub fn take_pairing_if_match(&self, code: &str) -> Result<(), String> {
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
let s = inner
.pairing
.as_ref()
.ok_or_else(|| "没有进行中的配对,请先在电脑上点「连接手机」".to_string())?;
if s.is_expired() {
inner.pairing = None;
return Err("配对码已过期(5 分钟),请重新生成".into());
}
if s.code != code.trim() {
return Err("配对码不正确".into());
}
inner.pairing = None; // 一次性
Ok(())
}
// ---------- 生命周期(§5.4) ----------
/// 启动:探测端口 → axum serve → beacon → GSMTC 监视。
pub async fn start(&self, app: &AppHandle) -> Result<(), String> {
{
let inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
if inner.running {
return Ok(());
}
}
// 本机标识:首次生成后持久化(beacon / NowPlaying 同源)
let music = app.state::<MusicManager>();
let mut settings = music.load_settings();
if settings.remote_device_id.trim().is_empty() {
settings.remote_device_id = pairing::random_device_id();
music.save_settings(&settings)?;
}
// 1) HTTP+WS 服务(端口探测 26124..26139)
let (port, server_task) = server::start(app.clone(), settings.remote_port).await?;
self.shutdown_tx.send_replace(false);
// 2) UDP beacon(3s;各网卡定向广播)
let payload = BeaconPayload {
service: "thing-music",
device_id: settings.remote_device_id.clone(),
name: std::env::var("COMPUTERNAME").unwrap_or_else(|_| "Thing".to_string()),
port,
proto_ver: PROTO_VER,
addrs: discovery::ipv4_broadcast_pairs()
.into_iter()
.map(|(ip, _)| ip.to_string())
.collect(),
};
let beacon_stop = Arc::new(AtomicBool::new(false));
let beacon_handle = discovery::spawn_beacon(payload, beacon_stop.clone());
// 封面持久化目录(P1 §7:重启后冷缓存可回源)
if let Ok(dir) = app.path().app_data_dir() {
self.covers.attach_dir(dir.join("remote_covers"));
}
// 3) GSMTC 监视(聚合/节流/封面/音量/会话事件;失败自动兜底,§3.1 失败策略)
let monitor = GsmtcMonitor::start(
app.clone(),
self.state_tx.clone(),
self.covers.clone(),
self.gsmtc_ok.clone(),
self.sessions_tx.clone(),
self.selected.clone(),
);
{
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
inner.running = true;
inner.port = port;
inner.server_task = Some(server_task);
inner.beacon_stop = Some(beacon_stop);
inner.beacon_handle = Some(beacon_handle);
inner.pairing = None;
}
*self.monitor.lock().unwrap_or_else(|e| e.into_inner()) = Some(monitor);
crate::logger::log_info(
"music-remote",
format!("手机互联已启动: ws://0.0.0.0:{port}(beacon :26123)").as_str(),
);
Ok(())
}
/// 停止:abort serve → 停 beacon → 停监视线程 → 清在线/配对。
pub fn stop(&self) {
let (server_task, beacon_stop, beacon_handle) = {
let mut inner = self.inner.lock().unwrap_or_else(|e| e.into_inner());
if !inner.running {
return;
}
inner.running = false;
inner.port = 0;
inner.pairing = None;
(
inner.server_task.take(),
inner.beacon_stop.take(),
inner.beacon_handle.take(),
)
};
// 停止信号:在途 WS 连接退出(§5.4 graceful;serve 直接 abort,手机端走重连)
self.shutdown_tx.send_replace(true);
if let Some(t) = server_task {
t.abort();
}
if let Some(stop) = beacon_stop {
stop.store(true, Ordering::Relaxed);
}
if let Some(h) = beacon_handle {
let _ = h.join(); // beacon 循环 ≤100ms 检查一次退出标志
}
let monitor = {
let mut guard = self.monitor.lock().unwrap_or_else(|e| e.into_inner());
guard.take()
};
if let Some(m) = monitor {
m.stop();
}
if let Ok(mut set) = self.online.lock() {
set.clear();
}
if let Ok(mut sel) = self.selected.lock() {
sel.take();
}
self.gsmtc_ok.store(false, Ordering::Relaxed);
crate::logger::log_info("music-remote", "手机互联已停止");
}
}
impl Default for RemoteManager {
fn default() -> Self {
Self::new()
}
}
// ---------------------------------------------------------------------------
// 启动钩子(setup.rs 调用)
// ---------------------------------------------------------------------------
/// 随应用启动:`remote_enabled = true` 时自动拉起服务(§5.4)。
pub fn init_on_launch(app: &AppHandle) {
let enabled = app
.try_state::<MusicManager>()
.map(|m| m.load_settings().remote_enabled)
.unwrap_or(false);
if !enabled {
return;
}
let app = app.clone();
tauri::async_runtime::spawn(async move {
let remote = app.state::<RemoteManager>();
if let Err(e) = remote.start(&app).await {
crate::logger::log_error(
"music-remote",
&format!("开机自启手机互联失败: {e}"),
);
}
});
}
// ---------------------------------------------------------------------------
// Tauri 命令(§5.1 命令表)
// ---------------------------------------------------------------------------
#[tauri::command]
#[specta::specta]
pub fn remote_get_config(app: AppHandle) -> RemoteConfig {
let music = app.state::<MusicManager>();
let s = music.load_settings();
let remote = app.state::<RemoteManager>();
RemoteConfig {
enabled: s.remote_enabled,
port: s.remote_port,
running: remote.is_running(),
running_port: remote.running_port(),
device_id: s.remote_device_id,
}
}
/// 开关(即时生效,§5.1)。
#[tauri::command]
#[specta::specta]
pub async fn remote_set_enabled(app: AppHandle, enabled: bool) -> Result<RemoteConfig, String> {
let music = app.state::<MusicManager>();
let mut s = music.load_settings();
s.remote_enabled = enabled;
music.save_settings(&s)?;
let remote = app.state::<RemoteManager>();
if enabled {
if let Err(e) = remote.start(&app).await {
// 启动失败:保留开关意图(下次启动重试),但如实上报未运行
crate::logger::log_error("music-remote", &format!("启动失败: {e}"));
return Err(e);
}
} else {
remote.stop();
}
Ok(RemoteConfig {
enabled,
port: s.remote_port,
running: remote.is_running(),
running_port: remote.running_port(),
device_id: s.remote_device_id,
})
}
#[tauri::command]
#[specta::specta]
pub fn remote_status(app: AppHandle) -> RemoteStatus {
let remote = app.state::<RemoteManager>();
let music = app.state::<MusicManager>();
let s = music.load_settings();
let online = remote.online_ids();
RemoteStatus {
running: remote.is_running(),
port: remote.running_port(),
online: s
.remote_devices
.iter()
.filter(|d| online.contains(&d.id))
.map(|d| RemoteDeviceView {
id: d.id.clone(),
name: d.name.clone(),
last_connected_ms: d.last_connected_ms,
online: true,
})
.collect(),
pairing: remote.pairing_info(),
}
}
/// 生成配对码 + 二维码 payload(前端 `qrcode` 渲染,§5.3)。
#[tauri::command]
#[specta::specta]
pub fn remote_start_pairing(app: AppHandle) -> Result<RemotePairingInfo, String> {
app.state::<RemoteManager>().start_pairing()
}
#[tauri::command]
#[specta::specta]
pub fn remote_cancel_pairing(app: AppHandle) {
app.state::<RemoteManager>().cancel_pairing();
}
/// 设备列表(元数据 + 在线态;token 永不出现在这里)。
#[tauri::command]
#[specta::specta]
pub fn remote_list_devices(app: AppHandle) -> Vec<RemoteDeviceView> {
let music = app.state::<MusicManager>();
let s = music.load_settings();
let remote = app.state::<RemoteManager>();
let online = remote.online_ids();
s.remote_devices
.into_iter()
.map(|d| RemoteDeviceView {
online: online.contains(&d.id),
id: d.id,
name: d.name,
last_connected_ms: d.last_connected_ms,
})
.collect()
}
/// 吊销设备(删表 + 删凭据;已建立的 WS 在下次重连时被拒)。
#[tauri::command]
#[specta::specta]
pub fn remote_revoke_device(app: AppHandle, id: String) -> Result<(), String> {
let music = app.state::<MusicManager>();
let mut s = music.load_settings();
s.remote_devices.retain(|d| d.id != id);
music.save_settings(&s)?;
crate::secrets::secret_delete(&pairing::token_key(&id))?;
let remote = app.state::<RemoteManager>();
remote.mark_online(&id, false);
crate::logger::log_info("music-remote", format!("已吊销设备 {id}").as_str());
Ok(())
}
/// 前端发布 Thing 本机播放队列(手机端「播放队列 / 选歌」的数据源)。
///
/// 队列活在前端 store(feiniuStore),Rust 只做快照转发;`items` 允许是完整队列
/// 的一段(见 [`proto::QueueItem::index`]),`total` 恒为完整长度。
#[tauri::command]
#[specta::specta]
pub fn remote_publish_queue(
app: AppHandle,
items: Vec<proto::QueueItem>,
index: i64,
total: i64,
) {
crate::logger::log_info(
"music-remote",
&format!(
"遥控队列更新: 本次 {} 条 / 共 {} 条,当前第 {} 条",
items.len(),
total,
index
),
);
app.state::<RemoteManager>()
.set_queue(proto::QueueSnapshot {
items,
index,
total: total.max(0),
});
}
+202
View File
@@ -0,0 +1,202 @@
//! 配对与设备表(MUSIC_REMOTE_PLAN §3.4)。
//!
//! - 配对码:6 位数字,Thing 设置页弹窗展示,**5 分钟有效期、一次性**
//! - 设备 token:32 字节随机 hex,入系统凭据管理器(`secrets.rs` 范式,键名
//! `music-remote-token-{deviceId}`);设备元数据(id/名/最后连接)落 settings
//! - 限速:hello 校验失败 3 次拉黑该 IP 60s;`/pair` 配对码校验同一限速(§3.4-4)
use std::collections::HashMap;
use std::sync::Mutex;
use std::time::{Duration, Instant};
use rand::Rng;
use serde::{Deserialize, Serialize};
use specta::Type;
/// 配对码有效期(§3.4-2)。
pub const PAIRING_TTL: Duration = Duration::from_secs(5 * 60);
/// 单 IP 失败阈值与拉黑时长(§3.4-4)。
const FAIL_LIMIT: u8 = 3;
const FAIL_BLOCK: Duration = Duration::from_secs(60);
/// 设备元数据(settings.json 持久化;**token 不在此**,见键名约定)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct RemoteDeviceMeta {
pub id: String,
pub name: String,
/// 最后一次成功连接(Unix 毫秒;0 = 从未连接)
#[serde(default)]
pub last_connected_ms: i64,
}
/// 进行中的配对会话(同一时刻至多一个)。
#[derive(Debug, Clone)]
pub struct PairingSession {
pub code: String,
pub created: Instant,
}
impl PairingSession {
pub fn generate() -> Self {
let code: u32 = rand::thread_rng().gen_range(0..1_000_000);
Self {
code: format!("{code:06}"),
created: Instant::now(),
}
}
pub fn is_expired(&self) -> bool {
self.created.elapsed() > PAIRING_TTL
}
/// 剩余秒数(前端倒计时用;已过期返回 0)。
pub fn seconds_left(&self) -> u64 {
PAIRING_TTL
.saturating_sub(self.created.elapsed())
.as_secs()
}
}
/// 凭据键名:与 `secrets.rs` 的服务名 `Thing` 组合成完整凭据项。
pub fn token_key(device_id: &str) -> String {
format!("music-remote-token-{device_id}")
}
/// 生成 32 字节随机 hex token(§3.4-3)。
pub fn random_token() -> String {
let mut buf = [0u8; 32];
rand::thread_rng().fill(&mut buf);
hex_encode(&buf)
}
/// 生成 16 字节随机 hex 设备 id。
pub fn random_device_id() -> String {
let mut buf = [0u8; 16];
rand::thread_rng().fill(&mut buf);
hex_encode(&buf)
}
fn hex_encode(bytes: &[u8]) -> String {
bytes.iter().map(|b| format!("{b:02x}")).collect()
}
/// 按 token 找设备:遍历 settings 中的设备 id,逐个读凭据库比对。
/// 设备数很少(个位数),O(n) 读可接受;token 不落 settings(§3.4-3)。
pub fn device_by_token(
devices: &[RemoteDeviceMeta],
token: &str,
) -> Option<RemoteDeviceMeta> {
if token.is_empty() {
return None;
}
for d in devices {
let stored = crate::secrets::read_or_empty(&token_key(&d.id));
if !stored.is_empty() && stored == token {
return Some(d.clone());
}
}
None
}
/// 单 IP 失败计数 / 拉黑表(hello 与 /pair 共用)。
#[derive(Default)]
pub struct FailTracker {
inner: Mutex<HashMap<String, FailState>>,
}
#[derive(Clone, Copy)]
struct FailState {
fails: u8,
last: Instant,
blocked_until: Option<Instant>,
}
impl FailTracker {
/// 该 IP 当前是否允许尝试(在拉黑窗口内 → false)。
pub fn allowed(&self, ip: &str) -> bool {
let map = self.inner.lock().unwrap_or_else(|e| e.into_inner());
match map.get(ip) {
Some(s) => match s.blocked_until {
Some(t) => Instant::now() >= t,
None => true,
},
None => true,
}
}
/// 记一次失败:累计 3 次拉黑 60s;60s 后的失败重新计数。
pub fn fail(&self, ip: &str) {
let mut map = self.inner.lock().unwrap_or_else(|e| e.into_inner());
let now = Instant::now();
let s = map.entry(ip.to_string()).or_insert(FailState {
fails: 0,
last: now,
blocked_until: None,
});
if let Some(t) = s.blocked_until {
if now >= t {
s.fails = 0;
s.blocked_until = None;
}
}
if now.duration_since(s.last) > FAIL_BLOCK {
s.fails = 0;
}
s.last = now;
s.fails += 1;
if s.fails >= FAIL_LIMIT {
s.blocked_until = Some(now + FAIL_BLOCK);
crate::logger::log_warn(
"music-remote",
&format!("IP {ip} 鉴权失败 {FAIL_LIMIT} 次,拉黑 60s"),
);
}
}
/// 成功后清零。
pub fn ok(&self, ip: &str) {
self.inner
.lock()
.unwrap_or_else(|e| e.into_inner())
.remove(ip);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pairing_code_format_and_ttl() {
let p = PairingSession::generate();
assert_eq!(p.code.len(), 6);
assert!(p.code.chars().all(|c| c.is_ascii_digit()));
assert!(!p.is_expired());
assert!(p.seconds_left() <= 300);
}
#[test]
fn fail_tracker_blocks_after_three() {
let t = FailTracker::default();
assert!(t.allowed("1.2.3.4"));
t.fail("1.2.3.4");
t.fail("1.2.3.4");
assert!(t.allowed("1.2.3.4"));
t.fail("1.2.3.4");
assert!(!t.allowed("1.2.3.4"));
// 其他 IP 不受影响
assert!(t.allowed("5.6.7.8"));
t.ok("1.2.3.4");
assert!(t.allowed("1.2.3.4"));
}
#[test]
fn token_shape() {
let t = random_token();
assert_eq!(t.len(), 64);
assert!(t.chars().all(|c| c.is_ascii_hexdigit()));
assert_eq!(random_device_id().len(), 32);
assert_eq!(token_key("abc"), "music-remote-token-abc");
}
}
+523
View File
@@ -0,0 +1,523 @@
//! 遥控协议类型(MUSIC_REMOTE_PLAN §4)。
//!
//! WS 线格式:JSON,`type` 字段判别,字段一律 camelCase。
//! 这些类型**不进 specta bindings**——协议对端是手机(LFMusic 在 `remote-proto.ts`
//! 手写一份镜像类型),Thing 前端不直接消费 WS;此处只负责 serde 序列化与单测。
//! 双端字段一旦改动,必须同步对端文档 §4 与 LFMusic 的镜像类型(计划"复制+注释互指")。
use serde::{Deserialize, Serialize};
/// 协议版本:不匹配时 `welcome` 带最新版本号,手机端提示升级(§4.2)。
pub const PROTO_VER: u32 = 1;
/// Thing 自身会话的 sessionId(§4.1)。
pub const THING_SELF_SESSION: &str = "thing.self";
/// Thing 自身的 AUMID(与 lib.rs `set_app_user_model_id` 一致)。
pub const THING_AUMID: &str = "thing.lfeng.me";
/// 控制能力位:手机端据此置灰按钮(§4.1)。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CanControl {
pub play: bool,
pub pause: bool,
pub next: bool,
pub prev: bool,
pub seek: bool,
}
/// 播放状态(§4.1 `status`)。
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum PlayStatus {
Playing,
Paused,
Stopped,
}
impl Default for PlayStatus {
fn default() -> Self {
Self::Stopped
}
}
/// 当前播放状态快照:WS `state` 消息的载荷(§4.1)。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NowPlaying {
/// 会话 key:Thing 自身 = [`THING_SELF_SESSION`],其余为 SourceAppUserModelId
pub session_id: String,
/// 来源应用显示名(AUMID 简化,友好名映射 P1)
pub source_app: String,
/// 是否 Thing 自身播放(封面/元数据兜底、seek 直通判定)
pub is_thing: bool,
pub title: String,
pub artist: String,
pub album: String,
/// 封面缓存键;封面从 `GET /cover/:hash` 拉取
pub cover_hash: Option<String>,
pub status: PlayStatus,
pub duration_sec: f64,
/// 推送时刻的播放位置(秒)
pub position_sec: f64,
/// 电脑时钟毫秒(源自 TimelineProperties.LastUpdatedTime,§6.4)。
/// **仅供校准**:手机端 elapsed 一律以本地收包时刻起算(§6.10)
pub position_updated_at_ms: i64,
pub playback_rate: f64,
pub can_control: CanControl,
/// 系统主音量(0.0~1.0;None = 音频端点不可用,手机端隐藏音量条)。P1 §7
pub volume: Option<f64>,
/// 系统主音量静音位
pub muted: bool,
/// 电脑标识(beacon 同源,多电脑预留)
pub device_id: String,
}
impl Default for NowPlaying {
fn default() -> Self {
Self {
session_id: String::new(),
source_app: String::new(),
is_thing: false,
title: String::new(),
artist: String::new(),
album: String::new(),
cover_hash: None,
status: PlayStatus::Stopped,
duration_sec: 0.0,
position_sec: 0.0,
position_updated_at_ms: 0,
playback_rate: 1.0,
can_control: CanControl {
play: false,
pause: false,
next: false,
prev: false,
seek: false,
},
volume: None,
muted: false,
device_id: String::new(),
}
}
}
impl NowPlaying {
/// 「无播放」快照(§5.2 两者都无:status = stopped,手机显示"电脑未在播放")。
pub fn stopped(device_id: &str) -> Self {
Self {
device_id: device_id.to_string(),
..Default::default()
}
}
}
/// 会话列表条目(P1 §7 多会话切换:手机端可选"控制哪个应用")。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SessionInfo {
pub session_id: String,
pub source_app: String,
pub title: String,
pub artist: String,
pub status: PlayStatus,
pub is_thing: bool,
/// 是否当前展示/控制目标(Thing 侧选中覆盖;无覆盖时为系统 current)
pub is_current: bool,
}
/// 播放队列条目(Thing 专属:本机播放器的队列,手机端可选歌)。
///
/// `index` 是**在完整队列里的绝对下标**——下发时允许只带当前附近的一段
/// (前端最多推 500 条,见 feiniuStore),手机端跳歌直接把 index 回传。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, specta::Type)]
#[serde(rename_all = "camelCase")]
pub struct QueueItem {
pub index: i64,
pub title: String,
pub artist: String,
pub duration_sec: f64,
}
/// 播放队列快照(WS `queue` 消息;`total` 是完整队列长度,可能大于 `items` 条数)。
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct QueueSnapshot {
pub items: Vec<QueueItem>,
/// 当前播放条目在完整队列中的下标(-1 = 未在队列中播放)
pub index: i64,
pub total: i64,
}
/// 会话 key(§4.1 / §6.5):Thing 自身固定为 `thing.self`,其余直接用 AUMID。
pub fn session_key(aumid: &str) -> String {
if is_thing_aumid(aumid) {
THING_SELF_SESSION.to_string()
} else {
aumid.to_string()
}
}
/// AUMID 是否为 Thing 自身。
pub fn is_thing_aumid(aumid: &str) -> bool {
aumid.eq_ignore_ascii_case(THING_AUMID)
}
/// 来源应用显示名(P0:取 AUMID 简化段;注册表友好名映射在 P1 §6.7)。
///
/// AUMID 形态:`PackageFamilyName!App` | `C:\Path\App.exe -Args` | `ProgId.App`。
pub fn source_display(aumid: &str) -> String {
// Thing 自身 AUMID 是标识符而非程序名,直接给友好名
if is_thing_aumid(aumid) {
return "Thing".to_string();
}
let core = aumid
.split(['!', '\\'])
.next_back()
.unwrap_or(aumid)
.split(' ')
.next()
.unwrap_or(aumid);
core.trim().trim_end_matches(".exe").to_string()
}
/// 控制动作(§4.2 `cmd.action`;Volume/Select 为 P1 扩展)。
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum CmdAction {
Play,
Pause,
Toggle,
Next,
Prev,
Stop,
Seek,
/// 系统主音量:args.level(0.0~1.0;>0 时顺带解除静音)
Volume,
/// 切换展示/控制的会话:args.sessionId(空串 = 取消覆盖,跟随系统 current)
Select,
/// 跳到队列指定条目(Thing 专属):args.index = 队列绝对下标
Jump,
}
/// `cmd` 的可选参数(serde default:缺省字段按0/空处理,各动作只读自己需要的)。
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CmdArgs {
/// seek 目标位置(秒)
#[serde(default)]
pub pos_sec: f64,
/// volume 目标音量(0.0~1.0)
#[serde(default)]
pub level: f64,
/// select 目标会话(空串 = 跟随系统)
#[serde(default)]
pub session_id: String,
/// jump 目标下标(队列绝对下标;-1 = 未提供)
#[serde(default = "jump_index_default")]
pub index: i64,
}
fn jump_index_default() -> i64 {
-1
}
/// WS 消息(§4.2)。`type` 字段判别;`state` 展平 [`NowPlaying`] 字段。
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "type",
rename_all = "camelCase",
rename_all_fields = "camelCase"
)]
pub enum WsMessage {
/// c→s:连接后首条,失败即断开
Hello {
token: String,
device_name: String,
proto_ver: u32,
},
/// s→c:鉴权通过
Welcome {
device_id: String,
device_name: String,
proto_ver: u32,
},
/// s→c:全量状态(连接后、变更、cmd 触发立即帧)
State {
#[serde(flatten)]
now: NowPlaying,
},
/// s→c:会话列表(P1;连接后、列表或当前目标变化时推送)
Sessions {
sessions: Vec<SessionInfo>,
},
/// s→c:Thing 本机播放队列(连接后、队列或当前曲目变化时推送)
Queue {
items: Vec<QueueItem>,
index: i64,
total: i64,
},
/// c→s:用户操作
Cmd {
id: String,
action: CmdAction,
#[serde(default, skip_serializing_if = "Option::is_none")]
args: Option<CmdArgs>,
},
/// s→c:回执(语义 = 指令已被接受/派发,状态以随后的 `state` 为准)
///
/// 显式 rename:外层 `rename_all = "camelCase"` 会把变体名也转成 `cmdAck`,
/// 而 §4.2 线格式与手机端都写的是 `cmd-ack` —— 不锁死就会让手机端把
/// **每一条错误回执都静默丢掉**(见 `cmd_ack_wire_type` 单测)。
#[serde(rename = "cmd-ack")]
CmdAck {
id: String,
ok: bool,
#[serde(default, skip_serializing_if = "Option::is_none")]
error: Option<String>,
},
/// c→s / s→c:30s 心跳
Ping { ts: i64 },
Pong { ts: i64 },
}
/// WinRT `DateTime.UniversalTime`(100ns since **1601-01-01 UTC**,即 FILETIME 纪元)→ Unix 毫秒。
/// `positionUpdatedAtMs` 的换算基准(§6.4:源是 `LastUpdatedTime`)。
///
/// 纪元是实测确认的(不是 .NET 的 0001-01-01):`gsmtc_dump` 里 QQMusic/Thing 会话的
/// `LastUpdatedTime` ≈1.343e17 ticks,按 1601 纪元换算分别落在"47 分钟前 / 4.5 秒前",
/// 与实际播放/暂停时刻吻合;按 0001 纪元则落在公元 426 年——Windows.Media.Control 的
/// `TimelineProperties.LastUpdatedTime` 走 FILETIME,用错纪元会得到巨额负数,
/// 手机端 `positionUpdatedAtMs > 0` 判定恒假 → 时钟偏差冻结(§6.10)形同虚设。
pub fn winrt_ticks_to_unix_ms(ticks: i64) -> i64 {
// 1601-01-01 → 1970-01-01:621355968 天 × 86400s × 1e7 ticks ÷ 1e4
ticks / 10_000 - 11_644_473_600_000
}
#[cfg(test)]
mod tests {
use super::*;
/// 序列化往返:保证双端 JSON 形状与字段名(camelCase)稳定(P0 单测项)。
#[test]
fn now_playing_roundtrip() {
let np = NowPlaying {
session_id: THING_SELF_SESSION.to_string(),
source_app: "网易云播放器".to_string(),
is_thing: false,
title: "园游会".to_string(),
artist: "周杰伦".to_string(),
album: "七里香".to_string(),
cover_hash: Some("ab12".to_string()),
status: PlayStatus::Playing,
duration_sec: 255.5,
position_sec: 12.25,
position_updated_at_ms: 1_790_000_000_000,
playback_rate: 1.0,
can_control: CanControl {
play: true,
pause: true,
next: true,
prev: true,
seek: true,
},
volume: Some(0.66),
muted: false,
device_id: "dev1".to_string(),
};
let msg = WsMessage::State { now: np.clone() };
let json = serde_json::to_string(&msg).unwrap();
// 字段名锁定(camelCase;双端漂移防线)
assert!(json.contains("\"type\":\"state\""));
assert!(json.contains("\"sessionId\""));
assert!(json.contains("\"coverHash\""));
assert!(json.contains("\"positionUpdatedAtMs\""));
assert!(json.contains("\"canControl\""));
assert!(json.contains("\"isThing\""));
assert!(json.contains("\"status\":\"playing\""));
assert!(json.contains("\"volume\":0.66"));
assert!(json.contains("\"muted\":false"));
let back: WsMessage = serde_json::from_str(&json).unwrap();
assert_eq!(back, msg);
}
/// P1:sessions 消息与 select/volume 动作的线格式锁定。
#[test]
fn sessions_and_p1_actions_roundtrip() {
let msg = WsMessage::Sessions {
sessions: vec![SessionInfo {
session_id: THING_SELF_SESSION.to_string(),
source_app: "Thing".into(),
title: "园游会".into(),
artist: "周杰伦".into(),
status: PlayStatus::Playing,
is_thing: true,
is_current: true,
}],
};
let json = serde_json::to_string(&msg).unwrap();
assert!(json.contains("\"type\":\"sessions\""));
assert!(json.contains("\"isCurrent\":true"));
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), msg);
let volume = WsMessage::Cmd {
id: "v1".into(),
action: CmdAction::Volume,
args: Some(CmdArgs {
level: 0.5,
..Default::default()
}),
};
let json = serde_json::to_string(&volume).unwrap();
assert!(json.contains("\"action\":\"volume\""));
assert!(json.contains("\"level\":0.5"));
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), volume);
let select = WsMessage::Cmd {
id: "s1".into(),
action: CmdAction::Select,
args: Some(CmdArgs {
session_id: THING_SELF_SESSION.into(),
..Default::default()
}),
};
let json = serde_json::to_string(&select).unwrap();
assert!(json.contains("\"action\":\"select\""));
assert!(json.contains("\"sessionId\":\"thing.self\""));
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), select);
// 队列下发 + 选歌(Thing 专属能力)的线格式锁定
let queue = WsMessage::Queue {
items: vec![QueueItem {
index: 7,
title: "园游会".into(),
artist: "周杰伦".into(),
duration_sec: 255.5,
}],
index: 7,
total: 120,
};
let json = serde_json::to_string(&queue).unwrap();
assert!(json.contains("\"type\":\"queue\""));
assert!(json.contains("\"items\""));
assert!(json.contains("\"durationSec\":255.5"));
assert!(json.contains("\"total\":120"));
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), queue);
let jump = WsMessage::Cmd {
id: "j1".into(),
action: CmdAction::Jump,
args: Some(CmdArgs {
index: 7,
..Default::default()
}),
};
let json = serde_json::to_string(&jump).unwrap();
assert!(json.contains("\"action\":\"jump\""));
assert!(json.contains("\"index\":7"));
// 缺 index 的旧客户端 → 反序列化为 -1(服务端据此拒绝)
assert_eq!(serde_json::from_str::<CmdArgs>(r#"{}"#).unwrap().index, -1);
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), jump);
}
#[test]
fn hello_ack_cmd_roundtrip() {
for msg in [
WsMessage::Hello {
token: "t".repeat(64),
device_name: "Pixel".to_string(),
proto_ver: PROTO_VER,
},
WsMessage::Welcome {
device_id: "d".to_string(),
device_name: "Thing".to_string(),
proto_ver: PROTO_VER,
},
WsMessage::Cmd {
id: "1".to_string(),
action: CmdAction::Seek,
args: Some(CmdArgs {
pos_sec: 42.0,
..Default::default()
}),
},
WsMessage::Cmd {
id: "2".to_string(),
action: CmdAction::Toggle,
args: None,
},
WsMessage::CmdAck {
id: "1".to_string(),
ok: false,
error: Some("frontend-unavailable".to_string()),
},
WsMessage::Ping { ts: 1 },
WsMessage::Pong { ts: 1 },
] {
let json = serde_json::to_string(&msg).unwrap();
let back: WsMessage = serde_json::from_str(&json).unwrap();
assert_eq!(back, msg, "{json}");
}
// action 枚举的线格式锁定
let json = serde_json::to_string(&WsMessage::Cmd {
id: "3".into(),
action: CmdAction::Next,
args: None,
})
.unwrap();
assert!(json.contains("\"action\":\"next\""));
// 无 args 时不出现该键
assert!(!json.contains("args"));
}
/// 回执的 `type` 必须是 `cmd-ack`(§4.2 表格与手机端 switch 的字面量)。
/// 外层 `rename_all = "camelCase"` 连变体名一起转,会产出 `cmdAck`——
/// 漏掉显式 rename 时手机端匹配不上,**每一条错误回执都被静默丢掉**
/// (表现为:指令被拒绝却无提示、手机端保持窗口只能等超时才回退)。
#[test]
fn cmd_ack_wire_type() {
let ack = WsMessage::CmdAck {
id: "1".into(),
ok: false,
error: Some("boom".into()),
};
let json = serde_json::to_string(&ack).unwrap();
assert!(json.contains("\"type\":\"cmd-ack\""), "{json}");
assert!(!json.contains("cmdAck"), "{json}");
assert_eq!(serde_json::from_str::<WsMessage>(&json).unwrap(), ack);
}
#[test]
fn session_key_and_display() {
assert_eq!(session_key(THING_AUMID), THING_SELF_SESSION);
assert_eq!(session_key("cloudmusic.exe"), "cloudmusic.exe");
assert!(is_thing_aumid("Thing.Lfeng.ME"));
assert_eq!(
source_display(r"KuGou\kugou.exe"),
"kugou".to_string()
);
assert_eq!(source_display("Museify_zzdnekvpz2s88!Spotify"), "Spotify");
// Thing 自身 AUMID → 友好名(手机端不应看到 thing.lfeng.me)
assert_eq!(source_display(THING_AUMID), "Thing");
}
/// WinRT DateTime(100ns since **1601-01-01**,FILETIME 纪元)→ Unix 毫秒(§6.4 换算基准)。
#[test]
fn winrt_datetime_to_unix_ms() {
// 1970-01-01 的 FILETIME ticks:621355968 天 × 86400s × 1e7
assert_eq!(winrt_ticks_to_unix_ms(116_444_736_000_000_000), 0);
// 2026-09-25 00:00:00 UTC ≈ 1_790_332_800_000 ms
let unix_ms = 1_790_332_800_000i64;
let ticks = (unix_ms + 11_644_473_600_000) * 10_000;
assert_eq!(winrt_ticks_to_unix_ms(ticks), unix_ms);
// 实测样本(gsmtc_dump 抓到的 Thing 自身会话 LastUpdatedTime):
// 对应 1790499938437 ms,即抓取时刻 4.5 秒前——按 0001 纪元算会落到公元 426 年
assert_eq!(
winrt_ticks_to_unix_ms(134_349_735_384_378_473),
1_790_499_938_437
);
// 0 = 来源从未上报过时间轴(bilibili PC 实测)→ 换算必为负,
// 调用方(glsmtc)据此钳成 0 作「无进度基准」哨兵
assert!(winrt_ticks_to_unix_ms(0) < 0);
}
}
+610
View File
@@ -0,0 +1,610 @@
//! 局域网服务:axum HTTP + WebSocket(MUSIC_REMOTE_PLAN §3.2 / §4.2 / §5.1 `server.rs`)。
//!
//! | 端点 | 用途 |
//! |---|---|
//! | `/ws` | 主通道:hello 鉴权、state 推送、cmd 控制、心跳 |
//! | `/api/state` | REST 快照兜底(Bearer) |
//! | `/cover/:hash` | 封面字节流(`<img>` 带不了 header → `?t=token`) |
//! | `/pair` | 配对换 token(6 位码 + 限速) |
//!
//! 全部监听 `0.0.0.0`;实际端口在启动时按 26124→26139 探测(§3.2),
//! 由 RemoteManager 写回 beacon 与配对二维码。
use std::net::SocketAddr;
use std::time::{Duration, Instant};
use axum::extract::ws::{Message as AxumWs, WebSocket, WebSocketUpgrade};
use axum::extract::{ConnectInfo, Path, Query, State};
use axum::http::{header, HeaderMap, StatusCode};
use axum::response::{IntoResponse, Response};
use axum::routing::{get, post};
use axum::{Json, Router};
use futures_util::{SinkExt, StreamExt};
use serde::{Deserialize, Serialize};
use tauri::{AppHandle, Emitter, Manager};
use super::glsmtc;
use super::pairing::{self, RemoteDeviceMeta};
use super::proto::{
CmdAction, CmdArgs, NowPlaying, WsMessage, PROTO_VER,
};
use super::RemoteManager;
use crate::music::{AudioEngine, MusicManager};
use crate::music::smtc::SMTC_BUTTON_EVENT;
/// WS 首条消息(hello)超时(§4.2 连接后首条)。
const HELLO_TIMEOUT: Duration = Duration::from_secs(10);
/// 心跳周期(§4.2 30s 双向判活)。
const HEARTBEAT: Duration = Duration::from_secs(30);
/// 超过该时长无任何入站消息 → 判死断开(§5.4 心跳判活)。
const IDLE_TIMEOUT: Duration = Duration::from_secs(90);
#[derive(Clone)]
pub struct AppState {
pub app: AppHandle,
}
/// 构建路由(§3.2 四个端点)。
pub fn router(app: AppHandle) -> Router {
Router::new()
.route("/ws", get(ws_upgrade))
.route("/api/state", get(api_state))
.route("/cover/:hash", get(cover))
.route("/pair", post(pair))
.with_state(AppState { app })
}
/// 启动服务:preferred=0 时从 26124 起,被占 +1 直至 26139(§3.2)。
/// 成功返回(实际端口, serve 任务句柄);stop 时由 RemoteManager abort。
pub async fn start(
app: AppHandle,
preferred: u16,
) -> Result<(u16, tokio::task::JoinHandle<()>), String> {
let from = if preferred == 0 { 26124 } else { preferred };
let to = from.clamp(26124, 26139).min(26139);
let mut bound: Option<(u16, tokio::net::TcpListener)> = None;
for port in from..=to {
match tokio::net::TcpListener::bind(("0.0.0.0", port)).await {
Ok(l) => {
bound = Some((port, l));
break;
}
Err(e) => {
crate::logger::log_warn(
"music-remote",
&format!("端口 {port} 绑定失败({e}),尝试下一个"),
);
}
}
}
let (port, listener) = bound.ok_or_else(|| {
format!("远程服务端口 {from}-{to} 全部不可用(被占用或无权限)")
})?;
let router = router(app);
let handle = tokio::task::spawn(async move {
let svc = router.into_make_service_with_connect_info::<SocketAddr>();
if let Err(e) = axum::serve(listener, svc).await {
// abort 时 axum::serve 返回的错误走这里降级为日志(abort 本身另算)
crate::logger::log_warn("music-remote", &format!("axum 服务结束: {e}"));
}
});
Ok((port, handle))
}
// ---------------------------------------------------------------------------
// 鉴权
// ---------------------------------------------------------------------------
fn bearer_token(headers: &HeaderMap) -> Option<String> {
headers
.get(header::AUTHORIZATION)?
.to_str()
.ok()?
.strip_prefix("Bearer ")
.map(|s| s.to_string())
}
/// 校验设备 token → 设备信息;失败为 None(不做限速——限速由调用方按场景加)。
fn validate_token(app: &AppHandle, token: &str) -> Option<RemoteDeviceMeta> {
let music = app.state::<MusicManager>();
let settings = music.load_settings();
pairing::device_by_token(&settings.remote_devices, token)
}
fn require_bearer(app: &AppHandle, headers: &HeaderMap) -> Result<RemoteDeviceMeta, StatusCode> {
let token = bearer_token(headers).ok_or(StatusCode::UNAUTHORIZED)?;
validate_token(app, &token).ok_or(StatusCode::UNAUTHORIZED)
}
// ---------------------------------------------------------------------------
// REST:/api/state、/cover/:hash
// ---------------------------------------------------------------------------
async fn api_state(
State(st): State<AppState>,
headers: HeaderMap,
) -> Result<Json<NowPlaying>, StatusCode> {
require_bearer(&st.app, &headers)?;
let remote = st.app.state::<RemoteManager>();
Ok(Json(remote.now_playing()))
}
#[derive(Deserialize)]
struct CoverQuery {
/// 鉴权 token(`<img>` 无法带 Authorization header,§3.2)
#[serde(rename = "t")]
t: Option<String>,
}
async fn cover(
State(st): State<AppState>,
Path(hash): Path<String>,
Query(q): Query<CoverQuery>,
headers: HeaderMap,
) -> Result<Response, StatusCode> {
let token = q.t.or_else(|| bearer_token(&headers));
let token = token.ok_or(StatusCode::UNAUTHORIZED)?;
validate_token(&st.app, &token).ok_or(StatusCode::UNAUTHORIZED)?;
let remote = st.app.state::<RemoteManager>();
let bytes = remote.covers.get(&hash).ok_or(StatusCode::NOT_FOUND)?;
// 访问日志不打印 query(§3.2):logger 不记录请求行,天然满足;此处只管响应
let ct = sniff_content_type(&bytes);
Ok(([(header::CONTENT_TYPE, ct)], bytes).into_response())
}
fn sniff_content_type(bytes: &[u8]) -> &'static str {
if bytes.starts_with(&[0x89, b'P', b'N', b'G']) {
"image/png"
} else if bytes.starts_with(&[0xFF, 0xD8]) {
"image/jpeg"
} else if bytes.len() > 12 && &bytes[0..4] == b"RIFF" && &bytes[8..12] == b"WEBP" {
"image/webp"
} else {
"application/octet-stream"
}
}
// ---------------------------------------------------------------------------
// POST /pair(§3.4)
// ---------------------------------------------------------------------------
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct PairRequest {
pairing_code: String,
device_name: String,
}
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct PairResponse {
token: String,
device_id: String,
}
#[derive(Serialize)]
struct HttpError {
error: String,
}
async fn pair(
State(st): State<AppState>,
ConnectInfo(addr): ConnectInfo<SocketAddr>,
Json(req): Json<PairRequest>,
) -> Result<(StatusCode, Json<PairResponse>), (StatusCode, Json<HttpError>)> {
let ip = addr.ip().to_string();
let remote = st.app.state::<RemoteManager>();
let denied = |msg: &str| {
(
StatusCode::TOO_MANY_REQUESTS,
Json(HttpError {
error: msg.to_string(),
}),
)
};
if !remote.auth.allowed(&ip) {
return Err(denied("尝试过于频繁,60s 后再试"));
}
// 配对码校验:存在 + 未过期 + 匹配(一次性:成功即清除)
match remote.take_pairing_if_match(&req.pairing_code) {
Ok(()) => remote.auth.ok(&ip),
Err(e) => {
remote.auth.fail(&ip);
return Err((
StatusCode::FORBIDDEN,
Json(HttpError { error: e }),
));
}
}
let device_id = pairing::random_device_id();
let token = pairing::random_token();
// token 先入凭据库,成功才落设备表(§3.4-3 顺序)
let key = pairing::token_key(&device_id);
if let Err(e) = crate::secrets::secret_write(&key, &token) {
crate::logger::log_error("music-remote", &format!("设备 token 写入凭据库失败: {e}"));
return Err((
StatusCode::INTERNAL_SERVER_ERROR,
Json(HttpError {
error: "保存设备凭据失败".to_string(),
}),
));
}
let name = if req.device_name.trim().is_empty() {
format!("手机设备 {}", &device_id[..6])
} else {
req.device_name.trim().to_string()
};
let music = st.app.state::<MusicManager>();
let mut settings = music.load_settings();
settings.remote_devices.push(RemoteDeviceMeta {
id: device_id.clone(),
name,
last_connected_ms: 0,
});
if let Err(e) = music.save_settings(&settings) {
crate::logger::log_error("music-remote", &format!("设备表落盘失败: {e}"));
}
crate::logger::log_info(
"music-remote",
format!("设备配对成功: {device_id}({ip})").as_str(),
);
Ok((
StatusCode::OK,
Json(PairResponse { token, device_id }),
))
}
// ---------------------------------------------------------------------------
// WebSocket(§4.2)
// ---------------------------------------------------------------------------
async fn ws_upgrade(
State(st): State<AppState>,
ConnectInfo(addr): ConnectInfo<SocketAddr>,
upgrade: WebSocketUpgrade,
) -> Response {
// 升级阶段不鉴权:手机 WebSocket 无法带 Authorization header,
// token 在升级后的首条 `hello` 消息里(§4.2)
upgrade
.on_upgrade(move |socket| handle_socket(st.app, addr, socket))
.into_response()
}
async fn handle_socket(app: AppHandle, addr: SocketAddr, socket: WebSocket) {
let ip = addr.ip().to_string();
let (mut sink, mut stream) = socket.split();
// 1) 首条必须是 hello(10s 超时)
let hello = match tokio::time::timeout(HELLO_TIMEOUT, stream.next()).await {
Ok(Some(Ok(AxumWs::Text(t)))) => match serde_json::from_str::<WsMessage>(&t) {
Ok(WsMessage::Hello {
token,
device_name,
..
}) => (token, device_name),
_ => {
let _ = sink.send(AxumWs::Close(None)).await;
return;
}
},
_ => {
let _ = sink.send(AxumWs::Close(None)).await;
return;
}
};
let (token, device_name) = hello;
let remote = app.state::<RemoteManager>();
if !remote.auth.allowed(&ip) {
let _ = sink.send(AxumWs::Close(None)).await;
return;
}
let device = match validate_token(&app, &token) {
Some(d) => {
remote.auth.ok(&ip);
d
}
None => {
remote.auth.fail(&ip);
crate::logger::log_warn("music-remote", &format!("hello 鉴权失败({ip})"));
let _ = sink.send(AxumWs::Close(None)).await;
return;
}
};
// 2) 上线登记 + 最后连接时间
remote.mark_online(&device.id, true);
touch_last_connected(&app, &device.id);
// 3) welcome + 首帧 state + 会话列表(§5.1 welcome → 全量;sessions 为 P1)
let mut state_rx = remote.state_tx.subscribe();
let mut sessions_rx = remote.sessions_rx();
let mut queue_rx = remote.queue_rx();
let mut rx = remote.shutdown_rx();
let device_id = device.id.clone();
let send_json = |msg: &WsMessage| -> String { serde_json::to_string(msg).unwrap_or_default() };
if sink
.send(AxumWs::Text(send_json(&WsMessage::Welcome {
device_id: device_id.clone(),
device_name: device_name.clone(),
proto_ver: PROTO_VER,
})))
.await
.is_err()
{
remote.mark_online(&device_id, false);
return;
}
{
let now = remote.now_playing();
let _ = sink
.send(AxumWs::Text(send_json(&WsMessage::State { now })))
.await;
}
{
let sessions = remote.sessions_snapshot();
let _ = sink
.send(AxumWs::Text(send_json(&WsMessage::Sessions { sessions })))
.await;
}
{
let q = remote.queue_snapshot();
let _ = sink.send(AxumWs::Text(send_json(&queue_msg(&q)))).await;
}
crate::logger::log_info(
"music-remote",
format!("WS 已连接: {device_name}({ip})").as_str(),
);
// 4) 主循环:入站消息 / 状态变更推送 / 心跳
let mut last_in = Instant::now();
let mut beat = tokio::time::interval(HEARTBEAT);
beat.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Delay);
loop {
tokio::select! {
// 心跳与判活(§4.2 / §5.4)
_ = beat.tick() => {
if last_in.elapsed() > IDLE_TIMEOUT {
crate::logger::log_warn("music-remote", &format!("心跳超时,断开 {device_name}({ip})"));
break;
}
if sink.send(AxumWs::Text(send_json(&WsMessage::Ping { ts: now_ms() }))).await.is_err() {
break;
}
}
// 服务停止
_ = rx.changed() => {
if *rx.borrow() { break; }
}
// 状态推送(watch:节流/Force 均已在监视线程收敛,§6.3)
changed = state_rx.changed() => {
if changed.is_err() { break; }
let now = state_rx.borrow_and_update().clone();
if sink.send(AxumWs::Text(send_json(&WsMessage::State { now }))).await.is_err() {
break;
}
}
// 会话列表变更(P1 多会话切换)
changed = sessions_rx.changed() => {
if changed.is_err() { break; }
let sessions = sessions_rx.borrow_and_update().clone();
if sink.send(AxumWs::Text(send_json(&WsMessage::Sessions { sessions }))).await.is_err() {
break;
}
}
// Thing 本机队列变更(前端发布:切歌 / 增删队列)
changed = queue_rx.changed() => {
if changed.is_err() { break; }
let snap = queue_rx.borrow_and_update().clone();
if sink.send(AxumWs::Text(send_json(&queue_msg(&snap)))).await.is_err() {
break;
}
}
incoming = stream.next() => {
match incoming {
Some(Ok(AxumWs::Text(t))) => {
last_in = Instant::now();
match serde_json::from_str::<WsMessage>(&t) {
Ok(WsMessage::Cmd { id, action, args }) => {
let res = dispatch_cmd(&app, action, args).await;
let ack = WsMessage::CmdAck {
id,
ok: res.is_ok(),
error: res.err(),
};
if sink.send(AxumWs::Text(send_json(&ack))).await.is_err() {
break;
}
// cmd 触发的 state 立即帧由监视线程 Force 产生(§6.3 例外)
}
Ok(WsMessage::Ping { ts }) => {
if sink.send(AxumWs::Text(send_json(&WsMessage::Pong { ts }))).await.is_err() {
break;
}
}
Ok(WsMessage::Pong { .. }) => {}
// 重复 hello / 非法消息:忽略(连接保持,状态以服务端为准)
_ => {}
}
}
Some(Ok(AxumWs::Ping(p))) => {
last_in = Instant::now();
if sink.send(AxumWs::Pong(p)).await.is_err() { break; }
}
Some(Ok(AxumWs::Pong(_))) => { last_in = Instant::now(); }
Some(Ok(AxumWs::Close(_))) | None => break,
Some(Err(_)) => break,
_ => {}
}
}
}
}
remote.mark_online(&device_id, false);
crate::logger::log_info(
"music-remote",
format!("WS 已断开: {device_name}({ip})").as_str(),
);
let _ = sink.send(AxumWs::Close(None)).await;
}
fn now_ms() -> i64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis() as i64)
.unwrap_or(0)
}
/// 队列快照 → WS 消息(`items`/`index`/`total` 展平成顶层字段)。
fn queue_msg(q: &super::proto::QueueSnapshot) -> WsMessage {
WsMessage::Queue {
items: q.items.clone(),
index: q.index,
total: q.total,
}
}
fn touch_last_connected(app: &AppHandle, device_id: &str) {
let music = app.state::<MusicManager>();
let mut settings = music.load_settings();
if let Some(d) = settings
.remote_devices
.iter_mut()
.find(|d| d.id == device_id)
{
d.last_connected_ms = now_ms();
if let Err(e) = music.save_settings(&settings) {
crate::logger::log_warn("music-remote", &format!("更新最后连接时间失败: {e}"));
}
}
}
/// 执行一条控制指令(§5.1 数据流 + §5.2 兜底规则;P1 扩展 Volume/Select 与 isThing 直通)。
async fn dispatch_cmd(
app: &AppHandle,
action: CmdAction,
args: Option<CmdArgs>,
) -> Result<(), String> {
let remote = app.state::<RemoteManager>();
let np = remote.now_playing();
let gsmtc_ok = remote.gsmtc_ok.load(std::sync::atomic::Ordering::Relaxed);
let a = args.clone().unwrap_or_default();
match action {
// seek:Thing 自身直通 AudioEngine(SMTC 回环无 seek 通道);其他会话走 GSMTC
CmdAction::Seek => {
if args.is_none() || a.pos_sec < 0.0 || !a.pos_sec.is_finite() {
return Err("seek 缺少/非法 args.posSec".into());
}
if np.is_thing {
let engine = app.state::<AudioEngine>();
let active = engine.state().active;
crate::logger::log_info(
"music-remote",
&format!("远程 seek(Thing) pos={:.1} 引擎会话={active}", a.pos_sec),
);
// 引擎无会话(重启后只恢复了队列、还没起播)时 seek 是静默空转,
// 手机端会白等保持窗口才回退——如实报错,让手机端立刻复位并提示
if !active {
return Err("电脑端播放器还没开始播放,先起播才能拖动进度".into());
}
engine.seek(a.pos_sec);
} else if gsmtc_ok {
gctl(np.session_id.clone(), action, args).await?;
} else {
return Err("当前模式不支持该会话的 seek".into());
}
}
// 系统主音量(P1 §7):level>0 自动解除静音(volume::set 内处理)
CmdAction::Volume => {
let Some(_) = args else {
return Err("volume 缺少 args.level".into());
};
if !a.level.is_finite() {
return Err("volume args.level 非法".into());
}
let level = a.level;
tokio::task::spawn_blocking(move || super::volume::set(level))
.await
.map_err(|e| format!("音量任务异常: {e}"))??;
}
// 目标会话切换(P1 §7):空 sessionId = 取消覆盖、跟随系统 current
CmdAction::Select => {
if args.is_none() {
return Err("select 缺少 args.sessionId".into());
}
remote.set_selected(&a.session_id);
}
// 选歌(Thing 专属):队列在前端 store,事件交回前端执行
CmdAction::Jump => {
if !np.is_thing {
return Err("只有 Thing 本机播放支持选歌".into());
}
if args.is_none() || a.index < 0 {
return Err("jump 缺少 args.index".into());
}
let total = remote.queue_snapshot().total;
if total > 0 && a.index >= total {
return Err(format!("队列里没有第 {} 首(共 {total} 首)", a.index + 1));
}
app.emit(super::REMOTE_JUMP_EVENT, a.index)
.map_err(|e| format!("派发到前端失败: {e}"))?;
}
// 按钮类:isThing 直通(P1 §7 跳过系统 SMTC 回环);其他会话 GSMTC;再退事件链兜底
_ => {
if np.is_thing {
let name = button_name(action, np.status == super::proto::PlayStatus::Playing)?;
app.emit(SMTC_BUTTON_EVENT, name)
.map_err(|e| format!("派发到前端失败: {e}"))?;
} else if gsmtc_ok {
gctl(np.session_id.clone(), action, args).await?;
} else {
let name = button_name(action, np.status == super::proto::PlayStatus::Playing)?;
app.emit(SMTC_BUTTON_EVENT, name)
.map_err(|e| format!("派发到前端失败: {e}"))?;
}
}
}
// cmd 触发立即推一帧(§6.3 例外)
remote.notify_state_force();
Ok(())
}
/// 按钮动作 → music-smtc-button 事件载荷(与 smtc.rs 的映射一致)。
fn button_name(action: CmdAction, playing: bool) -> Result<&'static str, String> {
Ok(match action {
CmdAction::Play => "play",
CmdAction::Pause => "pause",
CmdAction::Toggle => {
if playing {
"pause"
} else {
"play"
}
}
CmdAction::Next => "next",
CmdAction::Prev => "prev",
CmdAction::Stop => "stop",
_ => return Err("该动作不支持事件派发".into()),
})
}
/// GSMTC 控制:`.get()` 阻塞等待放 spawn_blocking(§3.1,绝不占 tokio worker/主线程)。
async fn gctl(
session_id: String,
action: CmdAction,
args: Option<CmdArgs>,
) -> Result<(), String> {
tokio::task::spawn_blocking(move || glsmtc::control(&session_id, action, args))
.await
.map_err(|e| format!("控制任务异常: {e}"))?
}
+57
View File
@@ -0,0 +1,57 @@
//! 系统主音量(MUSIC_REMOTE_PLAN P1 §7):MMDevice 默认输出端点的
//! `IAudioEndpointVolume`。
//!
//! 设计取舍:每次调用**现取 COM 对象**(CoCreate + Activate,µs 级开销),
//! 不跨线程持有接口指针——避开 windows-rs 接口的 Send/Sync 争议;
//! 调用频率受控(监视线程 500ms 读一次 + 手机拖动结束发一次 set)。
use windows::core::GUID;
use windows::Win32::Foundation::BOOL;
use windows::Win32::Media::Audio::Endpoints::IAudioEndpointVolume;
use windows::Win32::Media::Audio::{eMultimedia, eRender, IMMDevice, IMMDeviceEnumerator};
use windows::Win32::System::Com::{CLSCTX_ALL, CoCreateInstance};
/// CLSID_MMDeviceEnumerator(mmdevapi.h 固定值)
fn clsid_mm_device_enumerator() -> GUID {
GUID::from_u128(0xBCDE0395_E52F_467C_8E3D_C4579291_692E)
}
fn endpoint() -> Result<IAudioEndpointVolume, String> {
unsafe {
let enumerator: IMMDeviceEnumerator =
CoCreateInstance(&clsid_mm_device_enumerator(), None, CLSCTX_ALL)
.map_err(|e| format!("MMDeviceEnumerator 创建失败: {e}"))?;
let device: IMMDevice = enumerator
.GetDefaultAudioEndpoint(eRender, eMultimedia)
.map_err(|e| format!("默认音频输出端点不可用: {e}"))?;
device
.Activate(CLSCTX_ALL, None)
.map_err(|e| format!("IAudioEndpointVolume 激活失败: {e}"))
}
}
/// 读主音量(0.0~1.0)与静音位;端点不可用返回 None(NowPlaying.volume 置空)。
pub fn read() -> Option<(f64, bool)> {
let vol = endpoint().ok()?;
unsafe {
let v = vol.GetMasterVolumeLevelScalar().ok()? as f64;
let muted = vol.GetMute().ok()?.as_bool();
Some((v.clamp(0.0, 1.0), muted))
}
}
/// 设置主音量(0..1 自动 clamp);**level > 0 时顺带解除静音**——
/// 手机拖音量条本意就是"要出声",静音态下拖动即恢复(P1 手机端音量条语义)。
pub fn set(level: f64) -> Result<(), String> {
let vol = endpoint()?;
let l = level.clamp(0.0, 1.0) as f32;
unsafe {
vol.SetMasterVolumeLevelScalar(l, std::ptr::null())
.map_err(|e| format!("设置音量失败: {e}"))?;
if l > 0.0 {
vol.SetMute(BOOL(0), std::ptr::null())
.map_err(|e| format!("解除静音失败: {e}"))?;
}
}
Ok(())
}