media-session-reader 0.0.1

Cross-platform Rust library to read the current media session
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

use crate::{Cover, RepeatMode, Track};

use std::fs;

use mpris::{PlaybackStatus, PlayerFinder};

fn get_cover(url: Option<&str>) -> Option<Cover> {
    let url = url?;

    let data = if url.starts_with("file://") {
        let path = url.strip_prefix("file://")?;

        fs::read(path).ok()?
    } else {
        reqwest::blocking::get(url).ok()?.bytes().ok()?.to_vec()
    };

    Some(Cover {
        data,

        mime: "image/jpeg".to_string(),
    })
}

pub fn current_track() -> Option<Track> {
    let finder = PlayerFinder::new().ok()?;

    let player = finder.find_active().ok()?;

    let metadata = player.get_metadata().ok()?;

    let position = player.get_position().ok()?.as_millis() as u64;

    let duration = metadata.length()?.as_millis() as u64;

    let title = metadata.title().unwrap_or("Unknown").to_string();

    let artist = metadata
        .artists()
        .and_then(|a| a.first())
        .map(|x| x.to_string())
        .unwrap_or("Unknown".to_string());

    let album = metadata.album().map(|x| x.to_string());

    let album_artist = metadata
        .album_artists()
        .and_then(|a| a.first())
        .map(|x| x.to_string());

    let cover = get_cover(metadata.art_url());

    let playing = player.get_playback_status().ok()? == PlaybackStatus::Playing;

    let shuffle = player.get_shuffle().ok();

    let repeat = player.get_loop_status().ok().map(|mode| match mode {
        mpris::LoopStatus::None => RepeatMode::None,

        mpris::LoopStatus::Track => RepeatMode::Track,

        mpris::LoopStatus::Playlist => RepeatMode::Playlist,

        _ => RepeatMode::None,
    });

    let can_next = player.can_go_next().unwrap_or(false);

    let can_previous = player.can_go_previous().unwrap_or(false);

    let position_ms = position.min(duration);

    let track_number = metadata.track_number().map(|x| x as u32);

    let genre = metadata
        .genre()
        .and_then(|x| x.first())
        .map(|x| x.to_string());

    Some(Track {
        title,
        artist,
        album,
        album_artist,
        cover,
        duration_ms: duration,
        position_ms,
        playing,
        playback_rate: None,
        shuffle,
        repeat,
        can_next,
        can_previous,
        track_number,
        genre,
    })
}