Replace smol with async-std in music player

apps/music-player/Cargo.toml

@@ -10,12 +10,12 @@ path = "src/main.rs"
 required-features = ["bin"]
 
 [dependencies]
+async-std = { version = "1.12", optional = true, features = ["attributes"] }
 canary-magpie = { path = "../magpie", optional = true, features = ["async"] }
 futures-util = { version = "0.3", optional = true }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-smol = { version = "1.2", optional = true }
 zbus = { version = "3.5", optional = true }
 
 [features]
-bin = ["dep:canary-magpie", "dep:futures-util", "dep:smol", "dep:zbus"]
+bin = ["dep:async-std", "dep:canary-magpie", "dep:futures-util", "dep:zbus"]

apps/music-player/src/main.rs

@@ -1,13 +1,12 @@
 // Copyright (c) 2022 Marceline Cramer
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use std::path::Path;
-
 use canary_magpie::protocol::{
     ClientMessenger, CreatePanel, MagpieClientMsg, MagpieServerMsg, RecvMessage, MAGPIE_SOCK,
 };
 use canary_music_player::*;
-use smol::net::unix::UnixStream;
+
+use async_std::os::unix::net::UnixStream;
 
 pub type MagpieClient = ClientMessenger<UnixStream>;
 
@@ -125,13 +124,11 @@ async fn player_main(
     player: &PlayerProxy<'_>,
     magpie: &mut MagpieClient,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    use futures_util::StreamExt;
+    use futures_util::{FutureExt, StreamExt};
     let mut playback_status = player.receive_playback_status_changed().await.fuse();
     let mut metadata_tracker = player.receive_metadata_changed().await.fuse();
     let mut position_tracker = player.receive_position_changed().await.fuse();
-
     let mut metadata = Metadata::update_new(magpie, player.metadata().await?).await;
-    use futures_util::FutureExt;
 
     loop {
         futures_util::select! {
@@ -188,77 +185,76 @@ async fn player_main(
     Ok(())
 }
 
-fn main() {
+#[async_std::main]
+async fn main() {
     let args: Vec<String> = std::env::args().collect();
     let module_path = args
         .get(1)
         .expect("Please pass a path to a Canary script!")
         .to_owned();
 
-    smol::block_on(async {
+    let sock_path = canary_magpie::protocol::find_socket();
-        let sock_path = canary_magpie::protocol::find_socket();
+    let socket = UnixStream::connect(sock_path).await.unwrap();
-        let socket = UnixStream::connect(sock_path).await.unwrap();
+    let mut magpie = MagpieClient::new(socket);
-        let mut magpie = MagpieClient::new(socket);
+    let protocol = "tebibyte-media.desktop.music-player-controller".to_string();
-        let protocol = "tebibyte-media.desktop.music-player-controller".to_string();
+    let script = std::path::PathBuf::from(&module_path);
-        let script = std::path::PathBuf::from(&module_path);
+    let msg = CreatePanel {
-        let msg = CreatePanel {
+        id: 0,
-            id: 0,
+        protocol,
-            protocol,
+        script,
-            script,
+        init_msg: vec![],
-            init_msg: vec![],
+    };
+
+    let msg = MagpieServerMsg::CreatePanel(msg);
+    magpie.send_async(&msg).await.unwrap();
+
+    let dbus = zbus::Connection::session().await.unwrap();
+
+    let mut first_loop = true;
+    let mut connected = false;
+
+    loop {
+        if !first_loop {
+            let wait = std::time::Duration::from_secs(1);
+            async_std::task::sleep(wait).await;
+        }
+
+        first_loop = false;
+
+        if connected {
+            println!("Disconnected from MPRIS");
+            let msg = InMsg::Disconnected;
+            magpie.send_panel_json_async(0, &msg).await;
+            connected = false;
+        }
+
+        println!("Connecting to MPRIS...");
+
+        let player = match find_player(&dbus).await {
+            Ok(Some(player)) => player,
+            Ok(None) => {
+                eprintln!("Couldn't find player");
+                continue;
+            }
+            Err(err) => {
+                eprintln!("D-Bus error while finding player: {:?}", err);
+                return;
+            }
         };
 
-        let msg = MagpieServerMsg::CreatePanel(msg);
+        println!(
-        magpie.send_async(&msg).await.unwrap();
+            "Connected to \"{}\" ({})",
+            player.path().as_str(),
+            player.destination().as_str()
+        );
+        connected = true;
+        magpie.send_panel_json_async(0, &InMsg::Connected).await;
 
-        let dbus = zbus::Connection::session().await.unwrap();
+        match player_main(&player, &mut magpie).await {
-
+            Ok(()) => {}
-        let mut first_loop = true;
+            Err(err) => {
-        let mut connected = false;
+                eprintln!("D-Bus error while connected to player: {:?}", err);
-
-        loop {
-            if !first_loop {
-                let wait = std::time::Duration::from_secs(1);
-                std::thread::sleep(wait);
-            }
-
-            first_loop = false;
-
-            if connected {
-                println!("Disconnected from MPRIS");
-                let msg = InMsg::Disconnected;
-                magpie.send_panel_json_async(0, &msg).await;
-                connected = false;
-            }
-
-            println!("Connecting to MPRIS...");
-
-            let player = match find_player(&dbus).await {
-                Ok(Some(player)) => player,
-                Ok(None) => {
-                    eprintln!("Couldn't find player");
-                    continue;
-                }
-                Err(err) => {
-                    eprintln!("D-Bus error while finding player: {:?}", err);
-                    return;
-                }
-            };
-
-            println!(
-                "Connected to \"{}\" ({})",
-                player.path().as_str(),
-                player.destination().as_str()
-            );
-            connected = true;
-            magpie.send_panel_json_async(0, &InMsg::Connected).await;
-
-            match player_main(&player, &mut magpie).await {
-                Ok(()) => {}
-                Err(err) => {
-                    eprintln!("D-Bus error while connected to player: {:?}", err);
-                }
             }
         }
-    });
+    }
 }