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