Smoll rewrite

justfile

@@ -1,2 +1,6 @@
-load_dotenv:
+load-dotenv:
     set -a; source .env; set +a
+
+build-release:
+    cross build --target x86_64-pc-windows-gnu --release
+    cross build --target x86_64-unknown-linux-gnu --release

src/main.rs

@@ -1,6 +1,6 @@
-use chrono::Duration;
+use chrono::{Duration, Local, Utc};
 use discord_rich_presence::{
-    activity::{Activity, Assets, Button},
+    activity::{Activity, Assets, Button, Timestamps},
     DiscordIpc, DiscordIpcClient,
 };
 use std::{
@@ -8,15 +8,20 @@ use std::{
     sync::{Arc, Mutex},
     thread,
 };
-use tokio::signal;
+use tokio::{
+    signal,
+    sync::oneshot::{self, channel},
+};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let discord_app_id =
+    let discord_app_id = env::var("DISCORD_APP_ID").expect("Missing DISCORD_APP_ID in env");
-        env::var("DISCORD_APP_ID").expect("could not find `DISCORD_APP_ID` in env");
+    let lfm_username = env::var("LASTFM_USERNAME").expect("Missing LASTFM_USERNAME in env");
-    let lfm_username =
+    let lfm_api_key = env::var("LASTFM_API_KEY").expect("Missing LASTFM_API_KEY in env");
-        env::var("LASTFM_USERNAME").expect("could not find `LASTFM_USERNAME` in env");
+
-    let lfm_api_key = env::var("LASTFM_API_KEY").expect("could not find `LASTFM_API_KEY` in env");
+    let (send_stop, mut recv_stop) = channel::<()>();
+
+    let mut lfm = lastfm_rs::Client::new(lfm_api_key.as_str());
 
     let _ipc_client = Arc::new(Mutex::new(
         DiscordIpcClient::new(discord_app_id.as_str())
@@ -24,52 +29,71 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     ));
     let _ipc_client2 = Arc::clone(&_ipc_client);
 
-    let mut lfm = lastfm_rs::Client::new(lfm_api_key.as_str());
+    let mut ipc_client = _ipc_client.lock().unwrap();
-    let user_url = format!("https://www.last.fm/user/{}", lfm_username);
+    ipc_client.connect().unwrap();
-
+    drop(ipc_client);
-    {
-        let mut ipc_client = _ipc_client.lock().unwrap();
-        ipc_client.connect().unwrap();
-    }
 
     tokio::spawn(async move {
+        let user_url = format!("https://www.last.fm/user/{}", lfm_username);
+        let started_at = Utc::now();
         loop {
-            let tracks = lfm
+            match recv_stop.try_recv() {
-                .recent_tracks(&lfm_username)
+                Err(oneshot::error::TryRecvError::Empty) => {
-                .await
+                    let tracks_result = lfm
-                .with_limit(1)
+                        .recent_tracks(&lfm_username)
-                .send()
+                        .await
-                .await
+                        .with_limit(1)
-                .expect("no recent track found");
+                        .send()
+                        .await;
 
-            let last_track = &tracks.tracks[0];
+                    if let Ok(tracks) = tracks_result {
-            match &last_track.attrs {
+                        let last_track = &tracks.tracks[0];
-                Some(_) => {
+                        match &last_track.attrs {
-                    let details = format!("{} - {}", last_track.artist.name, last_track.name);
+                            Some(_) => {
-                    println!("Currently playing: {:#?}", details);
+                                let details =
-                    let state = format!("on {}", last_track.album.name);
+                                    format!("{} - {}", last_track.artist.name, last_track.name);
-                    let activity = Activity::new()
+                                println!(
-                        .assets(Assets::new().large_image(last_track.images[2].image_url.as_str()))
+                                    "{} Currently playing: {:#?}",
-                        .details(details.as_str())
+                                    Local::now().format("%Y/%m/%d %H:%M:%S"),
-                        .state(state.as_str())
+                                    details
-                        .buttons(vec![Button::new("Profile", &user_url)]);
+                                );
+                                let state = format!("on {}", last_track.album.name);
+                                let activity = Activity::new()
+                                    .assets(
+                                        Assets::new()
+                                            .large_image(last_track.images[2].image_url.as_str())
+                                            .large_text(&details),
+                                    )
+                                    .details(details.as_str())
+                                    .state(state.as_str())
+                                    .timestamps(Timestamps::new().start(started_at.timestamp()))
+                                    .buttons(vec![Button::new("Profile", &user_url)]);
 
-                    {
+                                let mut ipc_client = _ipc_client2.lock().unwrap();
-                        let mut ipc_client = _ipc_client2.lock().unwrap();
+                                ipc_client.set_activity(activity).unwrap();
-                        ipc_client.set_activity(activity).unwrap();
+                                drop(ipc_client);
+                            }
+                            None => {
+                                println!(
+                                    "{}: Current not playing...",
+                                    Local::now().format("%Y/%m/%d %H:%M:%S"),
+                                );
+                            }
+                        }
                     }
+                    thread::sleep(Duration::seconds(5).to_std().unwrap());
                 }
-                None => {
+                _ => {
-                    println!("Current not playing...")
+                    break;
                 }
             }
-            thread::sleep(Duration::seconds(5).to_std().unwrap());
         }
     });
 
     match signal::ctrl_c().await {
         Ok(()) => {
             println!("Shutting down...");
+            send_stop.send(()).unwrap();
             let mut ipc_client = _ipc_client.lock().unwrap();
             ipc_client.close().unwrap();
         }