@ohmykreee/dsh-remote-control 0.0.0-stage → 1.0.2

package/src/rust/src/media/vendor/apple_music.rs

@@ -0,0 +1,90 @@
+//! Apple Music / Cider private adapter.
+//!
+//! Apple Music normally uses SMTC/MediaRemote. Cider (a third-party Apple Music
+//! client) writes the current title to `Plugins/title.txt`; that local file is
+//! the private interface used when MediaRemote cannot identify the track.
+
+use std::path::PathBuf;
+
+use super::common;
+use crate::media::catalog::ParsedTitle;
+use crate::util;
+
+const SUFFIXES: &[&str] = &[" - Apple Music", " - Music", " - Cider"];
+const PRODUCT_NAMES: &[&str] = &["apple music", "music", "cider"];
+
+pub fn parse_title(raw: &str) -> Option<ParsedTitle> {
+    let text = common::strip_suffixes(common::normalize_spaces(raw), SUFFIXES);
+    if common::is_generic_title(&text, PRODUCT_NAMES) {
+        return None;
+    }
+    let mut parsed = common::split_title_artist(&text, false);
+    // Apple Music appends the album to the artist: "Floating Points — Cascade".
+    parsed.artist = parsed
+        .artist
+        .split(" — ")
+        .next()
+        .unwrap_or(&parsed.artist)
+        .trim()
+        .to_string();
+    if parsed.title.is_empty() {
+        return None;
+    }
+    Some(parsed)
+}
+
+/// Read Cider's local current-title file, checking the Windows and macOS
+/// locations used by the clients.
+#[allow(dead_code)] // Windows/macOS callers; Linux has no Cider client.
+pub fn cider_title() -> Option<ParsedTitle> {
+    let mut candidates: Vec<PathBuf> = Vec::new();
+    if let Some(appdata) = std::env::var_os("APPDATA").map(PathBuf::from) {
+        candidates.push(appdata.join("Cider").join("Plugins").join("title.txt"));
+    }
+    if let Some(home) = util::home_dir() {
+        candidates.push(
+            home.join("Library")
+                .join("Application Support")
+                .join("Cider")
+                .join("Plugins")
+                .join("title.txt"),
+        );
+        candidates.push(
+            home.join(".config")
+                .join("Cider")
+                .join("Plugins")
+                .join("title.txt"),
+        );
+    }
+    for path in candidates {
+        let Ok(text) = std::fs::read_to_string(path) else {
+            continue;
+        };
+        let Some(line) = text.lines().map(str::trim).find(|line| !line.is_empty()) else {
+            continue;
+        };
+        if let Some(parsed) = parse_title(line) {
+            return Some(parsed);
+        }
+    }
+    None
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_apple_music_title() {
+        let parsed = parse_title("Crush - Floating Points - Apple Music").unwrap();
+        assert_eq!(parsed.title, "Crush");
+        assert_eq!(parsed.artist, "Floating Points");
+        assert!(parse_title("Apple Music").is_none());
+    }
+
+    #[test]
+    fn strips_album_from_artist() {
+        let parsed = parse_title("Crush - Floating Points — Cascade").unwrap();
+        assert_eq!(parsed.artist, "Floating Points");
+    }
+}

package/src/rust/src/media/vendor/common.rs

@@ -0,0 +1,186 @@
+//! Shared helpers for the per-client vendor adapters.
+//!
+//! The adapters read only local client state (window titles, Cider's title
+//! file, NetEase's SQLite database). They never call a network API.
+
+use crate::media::catalog::{self, App, ParsedTitle};
+use crate::media::Media;
+
+/// Collapse runs of whitespace and trim.
+pub fn normalize_spaces(value: &str) -> String {
+    value.split_whitespace().collect::<Vec<_>>().join(" ")
+}
+
+/// Split a player window title into a title/artist pair.
+pub fn split_title_artist(value: &str, artist_first: bool) -> ParsedTitle {
+    let value = value.trim();
+    for separator in [" - ", " – "] {
+        if let Some((left, right)) = value.split_once(separator) {
+            let (left, right) = (left.trim(), right.trim());
+            if !left.is_empty() && !right.is_empty() {
+                return if artist_first {
+                    ParsedTitle {
+                        title: right.to_string(),
+                        artist: left.to_string(),
+                    }
+                } else {
+                    ParsedTitle {
+                        title: left.to_string(),
+                        artist: right.to_string(),
+                    }
+                };
+            }
+        }
+    }
+    ParsedTitle {
+        title: value.to_string(),
+        artist: String::new(),
+    }
+}
+
+/// Remove the client/product suffix used by most desktop players.
+pub fn strip_suffixes(value: String, suffixes: &[&str]) -> String {
+    let mut text = value.trim().to_string();
+    for suffix in suffixes {
+        if let Some(stripped) = strip_suffix_ci(&text, suffix) {
+            text = stripped.trim().to_string();
+            break;
+        }
+    }
+    text
+}
+
+pub fn strip_prefix_ci<'a>(value: &'a str, prefix: &str) -> Option<&'a str> {
+    if value.len() >= prefix.len()
+        && value.is_char_boundary(prefix.len())
+        && value[..prefix.len()].eq_ignore_ascii_case(prefix)
+    {
+        Some(&value[prefix.len()..])
+    } else {
+        None
+    }
+}
+
+pub fn strip_suffix_ci<'a>(value: &'a str, suffix: &str) -> Option<&'a str> {
+    if value.len() < suffix.len() {
+        return None;
+    }
+    let index = value.len() - suffix.len();
+    if !value.is_char_boundary(index) {
+        return None;
+    }
+    if value[index..].eq_ignore_ascii_case(suffix) {
+        Some(&value[..index])
+    } else {
+        None
+    }
+}
+
+/// True for product names, "connecting" placeholders and empty titles.
+pub fn is_generic_title(value: &str, product_names: &[&str]) -> bool {
+    let lower = value.trim().to_lowercase();
+    if lower.is_empty() {
+        return true;
+    }
+    if lower.contains("正在连接") || lower.contains("connecting") {
+        return true;
+    }
+    if product_names.iter().any(|name| lower == *name) {
+        return true;
+    }
+    matches!(lower.as_str(), "未知" | "unknown" | "未命名媒体")
+}
+
+/// Apply client-specific artist separators (e.g. `、`/`&` -> ` / `).
+pub fn normalize_artist(value: &str, replacements: &[(&str, &str)]) -> String {
+    let mut artist = value.trim().to_string();
+    for (from, to) in replacements {
+        artist = artist.replace(from, to);
+    }
+    normalize_spaces(&artist)
+}
+
+pub fn find_chars(haystack: &[char], needle: &[char]) -> Option<usize> {
+    if needle.is_empty() || haystack.len() < needle.len() {
+        return None;
+    }
+    haystack
+        .windows(needle.len())
+        .position(|window| window == needle)
+}
+
+/// Vendor-first policy for clients whose private interface is only a window
+/// title: use the system session when it is complete (controls and seek stay
+/// on SMTC/MPRIS), otherwise fall back to the client's private title.
+pub fn resolve_system_or_private(
+    app: App,
+    system: Option<Media>,
+    private: Option<Media>,
+) -> Option<Media> {
+    if let Some(system) = system.as_ref() {
+        let profile = catalog::profile_for_app(app);
+        if catalog::system_complete(profile, system) {
+            return Some(system.clone());
+        }
+    }
+    private.or(system)
+}
+
+/// Rotate a rolling window title so it starts at `marker`.
+pub fn rotate_to_marker(raw: &str, marker: &[char]) -> Option<String> {
+    let chars: Vec<char> = raw.chars().collect();
+    let index = find_chars(&chars, marker)?;
+    Some(
+        chars[index..]
+            .iter()
+            .chain(chars[..index].iter())
+            .collect::<String>(),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn system(title: &str, position: f64) -> Media {
+        let mut media = Media::new("test.exe");
+        media.title = title.to_string();
+        media.playback_status = "Playing".to_string();
+        media.start_time = 0.0;
+        media.end_time = 100.0;
+        media.position = position;
+        media.can_seek = true;
+        media
+    }
+
+    fn private(title: &str) -> Media {
+        let mut media = Media::new("test.exe");
+        media.title = title.to_string();
+        media.provider = "private".to_string();
+        media
+    }
+
+    #[test]
+    fn vendor_prefers_a_complete_system_session() {
+        let chosen = resolve_system_or_private(
+            App::Spotify,
+            Some(system("System", 10.0)),
+            Some(private("Private")),
+        )
+        .unwrap();
+        assert_eq!(chosen.title, "System");
+    }
+
+    #[test]
+    fn vendor_falls_back_to_private_when_system_is_incomplete() {
+        // QQ requires a real position; zero means the session is not complete.
+        let chosen = resolve_system_or_private(
+            App::QQMusic,
+            Some(system("System", 0.0)),
+            Some(private("Private")),
+        )
+        .unwrap();
+        assert_eq!(chosen.title, "Private");
+        assert_eq!(chosen.provider, "private");
+    }
+}

package/src/rust/src/media/vendor/kugou.rs

@@ -0,0 +1,52 @@
+//! KuGou Music private window-title adapter.
+//!
+//! KuGou rotates its window title, e.g.
+//! `还是他 - 酷狗音乐 陶喆 - 爱我` should become `爱我还是他 - 陶喆`.
+//! The "un-rotating" heuristic is ported from the reference project.
+
+use super::common;
+use crate::media::catalog::ParsedTitle;
+
+const PRODUCT_NAMES: &[&str] = &["酷狗音乐", "酷狗", "kugou"];
+
+pub fn parse_title(raw: &str) -> Option<ParsedTitle> {
+    let fixed = fix_title(raw);
+    if common::is_generic_title(&fixed, PRODUCT_NAMES) {
+        return None;
+    }
+    let parsed = common::split_title_artist(&fixed, false);
+    if parsed.title.is_empty() {
+        return None;
+    }
+    Some(parsed)
+}
+
+fn fix_title(raw: &str) -> String {
+    let rotated = common::rotate_to_marker(raw, &['酷', '狗']).unwrap_or_else(|| raw.to_string());
+    let mut text = rotated.trim().to_string();
+    text = common::strip_prefix_ci(&text, "酷狗音乐")
+        .or_else(|| common::strip_prefix_ci(&text, "酷狗"))
+        .unwrap_or(&text)
+        .trim_start_matches([' ', '-', '—', '–'])
+        .to_string();
+    text = text.trim_end_matches([' ', '-', '—', '–']).to_string();
+    text = text.replace('、', " / ");
+    // KuGou leaves `artist - song`; put the song first.
+    if let Some((artist, title)) = text.split_once(" - ") {
+        return format!("{} - {}", title.trim(), artist.trim());
+    }
+    text
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn fixes_rolling_kugou_title() {
+        let parsed = parse_title("还是他 - 酷狗音乐 陶喆 - 爱我").unwrap();
+        assert_eq!(parsed.title, "爱我还是他");
+        assert_eq!(parsed.artist, "陶喆");
+        assert!(parse_title("酷狗音乐").is_none());
+    }
+}

package/src/rust/src/media/vendor/kuwo.rs

@@ -0,0 +1,49 @@
+//! KuWo Music private window-title adapter.
+//!
+//! KuWo also rotates its window title and drops spaces around the separator:
+//! `nd&Daft Punk-酷我音乐 Starboy -The Week` -> `Starboy - The Weeknd / Daft Punk`.
+
+use super::common;
+use crate::media::catalog::ParsedTitle;
+
+const PRODUCT_NAMES: &[&str] = &["酷我音乐", "酷我", "kuwo"];
+
+pub fn parse_title(raw: &str) -> Option<ParsedTitle> {
+    let fixed = fix_title(raw);
+    if common::is_generic_title(&fixed, PRODUCT_NAMES) {
+        return None;
+    }
+    let parsed = common::split_title_artist(&fixed, false);
+    if parsed.title.is_empty() {
+        return None;
+    }
+    Some(parsed)
+}
+
+fn fix_title(raw: &str) -> String {
+    let rotated = common::rotate_to_marker(raw, &['酷', '我']).unwrap_or_else(|| raw.to_string());
+    let mut text = rotated.trim().to_string();
+    text = common::strip_prefix_ci(&text, "酷我音乐")
+        .or_else(|| common::strip_prefix_ci(&text, "酷我"))
+        .unwrap_or(&text)
+        .trim_start_matches([' ', '-', '—', '–'])
+        .to_string();
+    text = text.trim_end_matches([' ', '-', '—', '–']).to_string();
+    text = text.replace('&', " / ");
+    // KuWo drops the spaces around its separator.
+    text = text.replace(" -", " - ").replace("- ", " - ");
+    common::normalize_spaces(&text)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn fixes_rolling_kuwo_title() {
+        let parsed = parse_title("nd&Daft Punk-酷我音乐 Starboy -The Week").unwrap();
+        assert_eq!(parsed.title, "Starboy");
+        assert_eq!(parsed.artist, "The Weeknd / Daft Punk");
+        assert!(parse_title("酷我音乐").is_none());
+    }
+}

package/src/rust/src/media/vendor/mod.rs

@@ -0,0 +1,75 @@
+//! Vendor-specific local integrations.
+//!
+//! Each child module reads one third-party desktop client's local state (never
+//! its network API): window titles, Cider's title file, NetEase's SQLite
+//! database, etc. Keep this folder for vendor-only code so the generic media /
+//! notification / performance probes stay platform-focused.
+
+use crate::media::catalog::{App, ParsedTitle};
+use crate::media::Media;
+
+/// Which system branch a vendor adapter is running on. Vendor modules use this
+/// to pick the matching system-API rule (WinRT SMTC, MPRIS, Now Playing) while
+/// keeping all client-specific logic in one file.
+#[allow(dead_code)] // every platform constructs only its own variant.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Platform {
+    Windows,
+    Linux,
+    MacOS,
+}
+
+pub mod apple_music;
+pub mod common;
+pub mod kugou;
+pub mod kuwo;
+pub mod netease;
+pub mod qishui;
+pub mod qqmusic;
+pub mod spotify;
+pub mod wesing;
+pub mod youtube_music;
+
+/// Parse a client's window title using its vendor adapter.
+///
+/// `App::Browser` has no private interface: browser playback is handled by the
+/// system media session only.
+pub fn parse_title(app: App, raw: &str) -> Option<ParsedTitle> {
+    match app {
+        App::Netease => netease::parse_title(raw),
+        App::QQMusic => qqmusic::parse_title(raw),
+        App::Kugou => kugou::parse_title(raw),
+        App::Kuwo => kuwo::parse_title(raw),
+        App::Qishui => qishui::parse_title(raw),
+        App::WeSing => wesing::parse_title(raw),
+        App::Spotify => spotify::parse_title(raw),
+        App::AppleMusic => apple_music::parse_title(raw),
+        App::YouTubeMusic => youtube_music::parse_title(raw),
+        App::Browser => None,
+    }
+}
+
+/// Vendor-first media resolution.
+///
+/// The platform adapter identifies the application and passes the matching
+/// `Platform` plus its system session and optional private candidate. The
+/// vendor decides how to combine them:
+///
+/// * NetEase: system metadata/status/cover + CDP progress/liked; with no system
+///   session CDP supplies the complete media/transport; accessibility fallback;
+/// * other known clients: complete system session, else private title/UIA;
+/// * browser/unknown: the platform's system API only (handled by the caller).
+#[allow(dead_code)] // used by every platform adapter; kept cross-platform.
+pub fn resolve(
+    platform: Platform,
+    app: App,
+    system: Option<Media>,
+    private: Option<Media>,
+    fallback: impl FnOnce() -> Option<(f64, f64)>,
+) -> Option<Media> {
+    match app {
+        App::Netease => netease::merge(platform, system, private, fallback),
+        App::Browser => system,
+        _ => common::resolve_system_or_private(app, system, private),
+    }
+}