feat: Support mpris on MacOS.

Author: ccgauche

Cargo.lock

@@ -50,9 +50,13 @@ common-structs.workspace = true
 # -- Cookies auto retreival --
 rookie = "0.5.2"
 
+ctrlc = "3.5.0"
+
 [target."cfg(target_os = \"windows\")".dependencies]
 raw-window-handle = "0.4.3"
 winit = "0.26.1"
+[target."cfg(target_os = \"macos\")".dependencies]
+winit = "0.26.1"
 
 [profile.release]
 codegen-units = 1

crates/ytermusic/Cargo.toml

@@ -10,15 +10,14 @@ use std::{
     future::Future,
     panic,
     path::{Path, PathBuf},
-    process::exit,
     str::FromStr,
     sync::RwLock,
 };
 use systems::{logger::init, player::player_system};
 
 use crate::{
     consts::HEADER_TUTORIAL,
-    structures::sound_action::download_manager_handler,
+    structures::{media::run_window_handler, sound_action::download_manager_handler},
     systems::{logger::get_log_file_path, DOWNLOAD_MANAGER},
     utils::get_project_dirs,
 };
@@ -57,10 +56,11 @@ where
 }
 
 fn shutdown() {
+    info!("Shutdown signal sending");
     for _ in 0..1000 {
         SIGNALING_STOP.0.send(()).unwrap();
     }
-    exit(0);
+    info!("Shutdown signal sent");
 }
 
 static COOKIES: Lazy<RwLock<Option<String>>> = Lazy::new(|| RwLock::new(None));
@@ -70,8 +70,7 @@ pub fn try_get_cookies() -> Option<String> {
     cookies.clone()
 }
 
-#[tokio::main]
-async fn main() {
+fn main() {
     // Check if the first param is --files
     if let Some(arg) = std::env::args().nth(1) {
         match arg.as_str() {
@@ -137,15 +136,7 @@ async fn main() {
         error!("{e}");
         shutdown();
     }));
-    select! {
-        _ = async {
-            app_start().await
-        } => {},
-        _ = SIGNALING_STOP.1.recv_async() => {},
-        _ = tokio::signal::ctrl_c() => {
-            shutdown();
-        },
-    };
+    app_start();
 }
 
 fn cookies(specific_browser: Option<String>) -> Option<String> {
@@ -229,7 +220,8 @@ fn get_header_file() -> Result<(String, PathBuf), (std::io::Error, PathBuf)> {
     let fp = fp.join("headers.txt");
     std::fs::read_to_string(&fp).map_or_else(|e| Err((e, fp.clone())), |e| Ok((e, fp.clone())))
 }
-async fn app_start() {
+
+async fn app_start_main(updater_r: Receiver<ManagerMessage>, updater_s: Sender<ManagerMessage>) {
     STARTUP_TIME.log("Init");
 
     std::fs::create_dir_all(CACHE_DIR.join("downloads")).unwrap();
@@ -248,7 +240,6 @@ async fn app_start() {
     STARTUP_TIME.log("Startup");
 
     // Spawn the clean task
-    let (updater_s, updater_r) = flume::unbounded::<ManagerMessage>();
     tasks::clean::spawn_clean_task();
 
     STARTUP_TIME.log("Spawned clean task");
@@ -272,3 +263,26 @@ async fn app_start() {
     let mut manager = Manager::new(sa, player).await;
     manager.run(&updater_r).unwrap();
 }
+fn app_start() {
+    let (updater_s, updater_r) = flume::unbounded::<ManagerMessage>();
+    let updater_s_c = updater_s.clone();
+    ctrlc::set_handler(move || {
+        info!("CTRL-C received");
+        shutdown()
+    })
+    .expect("Error setting Ctrl-C handler");
+    std::thread::spawn(move || {
+        tokio::runtime::Builder::new_multi_thread()
+            .enable_all()
+            .build()
+            .expect("Failed to build runtime")
+            .block_on(async move {
+                select! {
+                    _ = app_start_main(updater_r, updater_s) => {},
+                    _ = SIGNALING_STOP.1.recv_async() => {},
+                };
+            });
+        info!("Runtime closed");
+    });
+    run_window_handler(&updater_s_c);
+}

crates/ytermusic/src/main.rs

@@ -154,6 +154,56 @@ fn get_handle(updater: &Sender<ManagerMessage>) -> Option<MediaControls> {
         .map_err(|e| format!("{e:?}")),
     )
 }
+#[cfg(not(target_os = "macos"))]
+pub fn run_window_handler(_updater: &Sender<ManagerMessage>) -> Option<()> {
+    use crate::SIGNALING_STOP;
+    loop {
+        if SIGNALING_STOP.1.try_recv() == Ok(()) {
+            use std::process::exit;
+
+            info!("event loop closed");
+            SIGNALING_STOP.0.send(()).unwrap();
+            exit(0);
+        }
+    }
+}
+
+#[cfg(target_os = "macos")]
+pub fn run_window_handler(updater: &Sender<ManagerMessage>) -> Option<()> {
+    use std::process::exit;
+
+    use winit::event_loop::EventLoop;
+    use winit::platform::macos::{ActivationPolicy, EventLoopExtMacOS};
+    use winit::window::WindowBuilder;
+
+    use crate::errors::handle_error_option;
+    let thread = std::thread::current();
+    info!("Current Thread Name: {:?}", thread.name());
+    info!("Current Thread ID:   {:?}", thread.id());
+
+    // On macOS, winit requires the EventLoop to be created on the main thread.
+    // Unlike Windows, we cannot use `new_any_thread`.
+    // We create a hidden window to ensure NSApplication is active and capable of receiving events.
+    let mut event_loop = EventLoop::new();
+    event_loop.set_activation_policy(ActivationPolicy::Regular);
+
+    // Create a hidden window. While souvlaki doesn't need the handle in the config,
+    // the existence of the window helps keep the event loop and application state valid.
+    let _window = handle_error_option(
+        updater,
+        "OS Error while creating media hook window",
+        WindowBuilder::new().with_visible(false).build(&event_loop),
+    )?;
+    event_loop.run(move |_event, _window_target, ctrl_flow| {
+        use crate::SIGNALING_STOP;
+        if SIGNALING_STOP.1.try_recv() == Ok(()) {
+            info!("event loop closed");
+            SIGNALING_STOP.0.send(()).unwrap();
+            *ctrl_flow = winit::event_loop::ControlFlow::Exit;
+            exit(0);
+        }
+    });
+}
 
 #[cfg(target_os = "windows")]
 fn get_handle(updater: &Sender<ManagerMessage>) -> Option<MediaControls> {

crates/ytermusic/src/structures/media.rs

@@ -24,7 +24,9 @@ use flume::{Receiver, Sender};
 use ratatui::{backend::CrosstermBackend, layout::Rect, Frame, Terminal};
 use ytpapi2::YoutubeMusicVideoRef;
 
-use crate::{structures::sound_action::SoundAction, systems::player::PlayerState, SIGNALING_STOP};
+use crate::{
+    shutdown, structures::sound_action::SoundAction, systems::player::PlayerState, SIGNALING_STOP,
+};
 
 use self::{device_lost::DeviceLost, item_list::ListItem, playlist::Chooser, search::Search};
 
@@ -255,6 +257,8 @@ impl Manager {
         )?;
         terminal.show_cursor()?;
 
+        shutdown();
+
         Ok(())
     }
 }