//! 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, handle: Mutex>>, } impl GsmtcMonitor { #[allow(clippy::too_many_arguments)] pub fn start( app: AppHandle, state_tx: Arc>, covers: Arc, gsmtc_ok: Arc, sessions_tx: Arc>>, selected: Arc>>, ) -> Self { let (tx, rx) = mpsc::channel::(); 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>, covers: Arc, gsmtc_ok: Arc, sessions_tx: Arc>>, selected: Arc>>, tx: Sender, rx: Receiver, ) { // 首次 WinRT 调用在此线程自动按 MTA 初始化(见模块注释) // RequestAsync() → Result>;外层 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::::new(move |_, _| { let _ = t.send(MonitorMsg::Change); Ok(()) }), ); let t = tx.clone(); let _ = m.SessionsChanged( &TypedEventHandler::::new(move |_, _| { let _ = t.send(MonitorMsg::Change); Ok(()) }), ); // 说明:MediaProperties/Timeline/PlaybackInfo 是 **Session 级**事件(挂在每条会话上, // 需随会话变化反复订阅/退订)。P0 简化为不订阅——聚合本身以 500ms 节拍轮询, // 语义变化最多延迟 ~500ms 上屏(发布规则见下),1Hz 进度窗口不受影响; // 会话级事件的精细化订阅列入 P1(计划 §7)。 } let mut last_publish: Option = None; let mut last_fp = String::new(); // 上次**发布**时的位置:位置不进语义指纹(每秒都变),单独用来识别跳变 let mut last_pos: Option = None; // 封面快捷缓存:coverKey → hash(避免同曲反复读缩略图;字节在 CoverStore) let mut cover_local: HashMap = HashMap::new(); // AUMID → 显示名缓存(注册表友好名,P1 §7) let mut name_cache: HashMap = HashMap::new(); // 会话列表指纹(变化才推 sessions 消息) let mut last_sessions_fp = String::new(); // 当前目标会话的事件订阅(P1 §7 会话级事件:随目标切换订阅/退订) let mut subs: Option = 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::() .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, name_cache: &mut HashMap, ) -> 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(可空)→ 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::().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, ) -> Option { 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> { 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::() { 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::() .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, bool) { if let Some(sid) = selected.filter(|s| !s.is_empty()) { let mut found: Option = 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, ) -> Vec { 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) -> Self { let mut tokens = Vec::new(); // 三个事件的 args 类型各不相同,逐个构造 handler(不能复用闭包) { let t = tx.clone(); let h = TypedEventHandler::::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::::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::::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 简化段(§6.7 P1)。 fn friendly_name(aumid: &str, cache: &mut HashMap) -> 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 { // 路径形 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::("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) -> 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: E) -> String { format!("{e}") } /// 按 sessionId 找会话(`thing.self` → AUMID 匹配;否则 AUMID 全等;回退 current)。 fn find_session(manager: &GsManager, session_id: &str) -> Result { 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}")) }