Add mpd. Rewrite.

src/main.rs

@@ -1,19 +1,9 @@
 extern crate chrono;
 extern crate dbus;
+extern crate mpd;
 
-use crate::dbus::blocking::stdintf::org_freedesktop_dbus::Properties;
-use chrono::{DateTime, Local, Utc};
-use dbus::{arg, blocking::Connection};
-use std::{env, time::Duration};
-use sys_info;
-
-const LOW: &str = "#[fg=colour119]";
-const MID: &str = "#[fg=colour220]";
-const HIGH: &str = "#[fg=colour197]";
-const END: &str = "#[fg=colour153]";
-const TRACK_NAME: &str = "#[fg=colour46]";
-const TRACK_ARTIST: &str = "#[fg=colour46]";
-const TRACK_TIME: &str = "#[fg=colour153]";
+mod config;
+mod utils;
 
 #[derive(Debug, Clone)]
 struct TrackInfo {
@@ -24,233 +14,20 @@ struct TrackInfo {
     status: String,
 }
 
-fn to_bar(value: i32, max: i32, low: f32, mid: f32) {
-    let mut bar = "".to_string();
-    let bar_sym = "▮".to_string();
-    if (value as f32) / (max as f32) < low {
-        bar.push_str(LOW);
-    } else if (value as f32) / (max as f32) < mid {
-        bar.push_str(MID);
-    } else {
-        bar.push_str(HIGH);
-    }
-    for i in 0..max {
-        if i < value as i32 {
-            bar.push_str(&bar_sym);
-        } else {
-            bar.push_str(" ")
-        }
-    }
-    bar.push_str(END);
-    bar.push_str("|");
-    print!("{}", bar)
-}
-
-fn mem_load_bar(bar_len: i32) {
-    let memory;
-    match sys_info::mem_info() {
-        Err(w) => panic!("{:?}", w),
-        Ok(mem_data) => memory = mem_data,
-    }
-    let len =
-        ((memory.total - memory.avail) as f32 / (memory.total as f32) * bar_len as f32) as i32;
-    to_bar(len, bar_len, 0.7, 0.9);
-    print!("{:.0} MiB#[default]", memory.avail / 1024);
-}
-
-fn cpu_load_bar(bar_len: i32) {
-    let cpu_count = match sys_info::cpu_num() {
-        Ok(c) => c,
-        Err(e) => panic!("{:?}", e),
-    };
-    let la_one: f32 = match sys_info::loadavg() {
-        Ok(l) => l.one as f32,
-        Err(e) => panic!("{:?}", e),
-    };
-    let len: f32 = la_one as f32 / cpu_count as f32 * bar_len as f32;
-    to_bar(len as i32, bar_len, 0.3, 0.7);
-    print!("{:.2} LA1#[default]", la_one);
-}
-
-fn get_player() -> Result<Vec<String>, Box<dyn std::error::Error>> {
-    let conn = Connection::new_session()?;
-    let proxy = conn.with_proxy("org.freedesktop.DBus", "/", Duration::from_millis(5000));
-    let (names,): (Vec<String>,) = proxy.method_call("org.freedesktop.DBus", "ListNames", ())?;
-    let mut players: Vec<String> = Vec::new();
-    for name in names {
-        if name.contains("org.mpris.MediaPlayer2") {
-            players.push(name);
-        }
-    }
-
-    Ok(players)
-}
-
-fn player_info(players: Vec<String>) -> Result<TrackInfo, Box<dyn std::error::Error>> {
-    let mut players_vec: Vec<TrackInfo> = Vec::new();
-    for player in players {
-        let mut track_info = TrackInfo {
-            artist: "".to_string(),
-            title: "".to_string(),
-            position: "".to_string(),
-            duration: "".to_string(),
-            status: "".to_string(),
-        };
-        let conn = Connection::new_session()?;
-        let proxy = conn.with_proxy(
-            player,
-            "/org/mpris/MediaPlayer2",
-            Duration::from_millis(5000),
-        );
-        let metadata: Box<dyn arg::RefArg> =
-            proxy.get("org.mpris.MediaPlayer2.Player", "Metadata")?;
-        let mut iter = metadata.as_iter().unwrap();
-        while let Some(key) = iter.next() {
-            if key.as_str() == Some("xesam:title") {
-                if let Some(title) = iter.next().unwrap().as_str() {
-                    track_info.title = title.to_string();
-                }
-            }
-            if key.as_str() == Some("mpris:length") {
-                if let Some(length) = iter.next().unwrap().as_i64() {
-                    track_info.duration = format_time(length / 1000000);
-                }
-            }
-            if key.as_str() == Some("xesam:artist") {
-                if let Some(mut artists) = iter.next().unwrap().as_iter() {
-                    while let Some(artist) = artists.next() {
-                        if let Some(mut line) = artist.as_iter() {
-                            track_info.artist = line.next().unwrap().as_str().unwrap().to_string();
-                        }
-                    }
-                }
-            }
-        }
-        let position: Box<dyn arg::RefArg> =
-            proxy.get("org.mpris.MediaPlayer2.Player", "Position")?;
-        track_info.position = format_time(position.as_i64().unwrap() / 1000000);
-        // ugly
-        let _status_text_box: Box<dyn arg::RefArg> =
-            proxy.get("org.mpris.MediaPlayer2.Player", "PlaybackStatus")?;
-        let _status_text = _status_text_box.as_str().unwrap();
-        match _status_text.as_ref() {
-            "Playing" => track_info.status = "▶".to_string(),
-            "Paused" => track_info.status = "⏸".to_string(),
-            _ => track_info.status = "⏹".to_string(),
-        };
-        players_vec.push(track_info);
-    }
-    for player in &players_vec {
-        if player.status == "▶".to_string() {
-            return Ok(player.clone());
-        }
-    }
-    Ok(players_vec[players_vec.len() - 1].clone())
-}
-
-fn format_time(sec: i64) -> String {
-    let minutes = sec / 60;
-    let secondes = sec % 60;
-    let result = format!("{:02}:{:02}", minutes, secondes);
-    result.to_string()
-}
-
-fn get_time(utc: bool, mut format: &str) {
-    // Format reference: https://docs.rs/chrono/0.4.10/chrono/format/strftime/index.html
-    if format.len() == 0 {
-        format = "%H:%M";
-    }
-    if utc {
-        let local_time = Local::now();
-        let utc_time = DateTime::<Utc>::from_utc(local_time.naive_utc(), Utc);
-        println!("{}", utc_time.format(format));
-    } else {
-        let local_time = Local::now();
-        println!("{}", local_time.format(format));
-    }
-}
-
 fn main() {
-    let args: Vec<String> = env::args().collect();
-    let help_text: &str = "Available commands -mb, -cb, -tl <TIME FORMAT>, -tu <TIME FORMAT>, -p";
-    match args.len() {
-        1 => {
-            panic!(help_text);
-        }
-        2 => match args[1].as_ref() {
-            "-cb" => cpu_load_bar(15),
-            "-mb" => mem_load_bar(15),
-            "-tl" => get_time(false, ""),
-            "-tu" => get_time(true, ""),
-            "-p" => match player_info(get_player().unwrap()) {
-                Ok(mut track_info) => {
-                    let mut title_len = 30;
-                    let mut artist_len = 30;
-                    let mut separator: String = " — ".to_string();
-                    let max_shift = 6;
-                    if track_info.artist.chars().count() == 0 {
-                        separator = "".to_string();
-                        title_len += artist_len;
-                    }
-                    if artist_len + max_shift >= track_info.artist.chars().count() {
-                        artist_len = track_info.artist.chars().count()
-                    }
-                    if track_info.artist.len() > artist_len {
-                        let mut artist: String = String::new();
-                        let mut counter = 0;
-                        for ch in track_info.artist.chars() {
-                            if counter == artist_len {
-                                artist.push_str("..");
-                                break;
-                            }
-                            artist.push(ch);
-                            counter += 1;
-                        }
-                        track_info.artist = artist;
-                    }
-                    if title_len + max_shift >= track_info.title.chars().count() {
-                        title_len = track_info.title.chars().count()
-                    }
-                    if track_info.title.len() > title_len {
-                        let mut title: String = String::new();
-                        let mut counter = 0;
-                        for ch in track_info.title.chars() {
-                            if counter == title_len {
-                                title.push_str("..");
-                                break;
-                            }
-                            title.push(ch);
-                            counter += 1;
-                        }
-                        track_info.title = title;
-                    }
-                    println!(
-                        "#[none]#[bold]{}{}{}#[none]{}{}{}{} {}[{}/{}] {} {}#[default]",
-                        TRACK_NAME,
-                        track_info.title,
-                        END,
-                        separator,
-                        TRACK_ARTIST,
-                        track_info.artist,
-                        END,
-                        TRACK_TIME,
-                        track_info.position,
-                        track_info.duration,
-                        track_info.status,
-                        END,
-                    );
-                }
-                Err(_e) => println!("No music playing"),
-            },
-            _ => panic!(help_text),
-        },
-        3 => match args[1].as_ref() {
-            "-tl" => get_time(false, args[2].as_ref()),
-            "-tu" => get_time(true, args[2].as_ref()),
-            _ => panic!(help_text),
-        },
-        _ => {
-            panic!(help_text);
-        }
+    let conf = config::read();
+    // cpu          - cpu usage bar
+    // mem          - mem usage bar
+    // mpris        - player info using MPRIS2 interface
+    // mpd          - player info using MPD native interface
+    // utctime      - utc time
+    // localtime    - local time
+    match conf.action {
+        config::Action::Cpu => utils::cpu_load_bar(15, &conf),
+        config::Action::Mem => utils::mem_load_bar(15, &conf),
+        config::Action::Mpris => utils::mpris(&conf),
+        config::Action::Utctime => utils::get_time(true, ""),
+        config::Action::Localtime => utils::get_time(false, ""),
+        config::Action::Mpd => utils::mpd(&conf),
     }
 }