lyrics-next 0.2.1

在终端下为 mpd/mpris 提供歌词.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

mod mpd;
mod mpris;

pub use mpd::MpdPlayer;
pub use mpris::MprisPlayer;

use crate::error::LyricsError;

#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub enum TrackId {
    Mpris(String),
    Mpd(u32),
    #[default]
    None,
}

impl TrackId {
    pub fn is_no_track(&self) -> bool {
        matches!(self, TrackId::None)
    }
}

#[derive(Debug, Clone, PartialEq)]
pub struct SongInfo {
    pub track_id: TrackId,
    pub title: String,
    pub artist: String,
    pub album: String,
    pub duration: f64,
}

impl Default for SongInfo {
    fn default() -> Self {
        Self {
            track_id: TrackId::None,
            title: Default::default(),
            artist: Default::default(),
            album: Default::default(),
            duration: Default::default(),
        }
    }
}

impl SongInfo {
    #[allow(dead_code)]
    fn normalized(&self) -> Self {
        use crate::utils::normalize_text;
        Self {
            title: normalize_text(&self.title),
            artist: normalize_text(&self.artist),
            duration: 0.,
            ..self.clone()
        }
    }

    pub(crate) fn track_support(&self) -> bool {
        self.track_id.is_no_track()
    }
}

#[derive(Clone, PartialEq, Eq, Default)]
pub enum PlayerAction {
    #[default]
    Toggle,
    Left,
    Right,
    Next,
    Previous,
}

pub trait Player {
    fn get_current_song(&self) -> impl std::future::Future<Output = Result<SongInfo, LyricsError>>;
    fn get_position(&self) -> impl std::future::Future<Output = Result<f64, LyricsError>>;
    fn player_action(
        &self,
        action: PlayerAction,
        song: &SongInfo,
    ) -> impl std::future::Future<Output = Result<(), LyricsError>>;
}

pub async fn get_current_song() -> Result<SongInfo, LyricsError> {
    let protocol = {
        let config = crate::config::get_config().read().unwrap();
        config.player_filter.protocol
    };

    match protocol {
        crate::config::PlayerProtocol::Auto => {
            // 优先尝试 MPD
            match MpdPlayer.get_current_song().await {
                Ok(song) => Ok(song),
                Err(_) => {
                    // MPD 失败，回退到 MPRIS
                    MprisPlayer.get_current_song().await
                }
            }
        }
        crate::config::PlayerProtocol::Mpd => MpdPlayer.get_current_song().await,
        crate::config::PlayerProtocol::Mpris => MprisPlayer.get_current_song().await,
    }
}

pub async fn get_position() -> Result<f64, LyricsError> {
    let protocol = {
        let config = crate::config::get_config().read().unwrap();
        config.player_filter.protocol
    };

    match protocol {
        crate::config::PlayerProtocol::Auto => {
            // 优先尝试 MPD
            match MpdPlayer.get_position().await {
                Ok(pos) => Ok(pos),
                Err(_) => {
                    // MPD 失败，回退到 MPRIS
                    MprisPlayer.get_position().await
                }
            }
        }
        crate::config::PlayerProtocol::Mpd => MpdPlayer.get_position().await,
        crate::config::PlayerProtocol::Mpris => MprisPlayer.get_position().await,
    }
}

pub async fn player_action(action: PlayerAction, song: &SongInfo) -> Result<(), LyricsError> {
    let protocol = {
        let config = crate::config::get_config().read().unwrap();
        config.player_filter.protocol
    };

    match protocol {
        crate::config::PlayerProtocol::Auto => {
            // 优先尝试 MPD
            match MpdPlayer.player_action(action.clone(), song).await {
                Ok(()) => Ok(()),
                Err(_) => {
                    // MPD 失败，回退到 MPRIS
                    MprisPlayer.player_action(action, song).await
                }
            }
        }
        crate::config::PlayerProtocol::Mpd => MpdPlayer.player_action(action, song).await,
        crate::config::PlayerProtocol::Mpris => MprisPlayer.player_action(action, song).await,
    }
}