libminau 0.1.0

A library version of Minau, a music player built directly on top of Symphonia and CPAL.
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

#![doc = "libminau - A flexible audio playback library"]
#![allow(unused)]

mod display_image;
mod display_info;
mod m3u;
mod play_url;

pub mod player;
pub mod error;

pub use player::{
    Player,
    LocalPlayer,
    StreamPlayer,
    PlaybackState,
};
pub use player::metadata::MetaData;
pub use error::{Error, Result};

pub use m3u::Playlist;


#[cfg(test)]
mod examples {
    use std::time::Duration;

    use async_compat::CompatExt;

    use super::*;

    #[test]
    fn local_playback() -> crate::Result<()> {
        let mut player = LocalPlayer::new("/home/konoha/Music/Music/Take Me There.mp3")?;
        
        // Get metadata
        let metadata = player.metadata();
        println!("Title: {:?}", metadata.title());
        println!("Artist: {:?}", metadata.artist());
        
        // Play
        player.play()?;
        player.set_volume(0.5)?;
        
        std::thread::sleep(std::time::Duration::from_secs(5));
        
        // Seek
        player.seek(std::time::Duration::from_secs(30))?;
        
        std::thread::sleep(std::time::Duration::from_secs(5));

        // Stop
        player.pause()?;
        
        Ok(())
    }

    async fn streaming_playback() -> crate::Result<()> {
        let player = StreamPlayer::new("https://kathy.torontocast.com:3330/", 0.8).await?;
        
        smol::block_on(async {
            smol::Timer::after(Duration::from_secs(10)).await;
        });
        
        player.pause();
        println!("Downloaded: {:.2} MB", player.downloaded_mb());
        
        Ok(())
    }

    #[test]
    fn playlist_usage() -> crate::Result<()> {
        let playlist = Playlist::from_file("/home/konoha/Music/MusicList/chill.m3u8")
            .unwrap();
        
        for entry in playlist.entries() {
            println!("Playing: {:?}", entry.title);
            if entry.path.starts_with("http://") || entry.path.starts_with("https://") {
                smol::block_on(async {
                    let mut player = Player::from_url(&entry.path, 1.0).compat().await.unwrap();
                    player.play().unwrap();
                    // player.wait_until_finished().await;
                    smol::Timer::after(Duration::from_secs(10)).await;
                });
                continue;
            } else {
                smol::block_on(async {
                    let mut player = Player::from_file(&entry.path).unwrap();
                    player.play().unwrap();
                    // player.wait_until_finished().await;
                    smol::Timer::after(Duration::from_secs(10)).await;
                });
                continue;
            }

        }
        
        Ok(())
    }

    fn unified_player() -> crate::Result<()> {
        // local file
        let mut player = Player::from_file("music.mp3")?;
        player.set_volume(0.7)?;

        player.play().unwrap();
        smol::block_on(player.wait_until_finished());
        
        // Streaming
        smol::block_on(async {
            let player = Player::from_url("https://example.com/stream.mp3", 0.7).await.expect("Failed to stream url music");
            player.pause().expect("Failed to stop music");
        });
        
        Ok(())
    }
}