Adding rodio to music backend🎉

muzik-offline/src-tauri/Cargo.toml

@@ -40,6 +40,7 @@ printpdf = "0.7.0"
 tabled = "0.16.0"
 walkdir = "2.5.0"
 futures = "0.3.31"
+rodio = "0.20.1"
 
 [dependencies.uuid]
 version = "1.11.0"

muzik-offline/src-tauri/src/app/setup.rs

@@ -1,4 +1,6 @@
-use crate::components::audio_manager::BackendStateManager;
+use crate::components::audio_manager::AppAudioManager;
+use crate::components::kira_audio_manager::KiraManager;
+use crate::components::rodio_audio_manager::RodioManager;
 use crate::database::db_api::{get_image_from_tree, get_null_cover_from_tree, get_thumbnail, get_wallpaper};
 use crate::database::db_manager::DbManager;
 use kira::manager::{backend::DefaultBackend, AudioManager, AudioManagerSettings};
@@ -16,15 +18,28 @@ use crate::utils::general_utils::get_random_port;
 
 use super::setup_macos;
 
-/// Initializes the BackendStateManager with required settings.
-pub fn initialize_audio_manager() -> Arc<Mutex<BackendStateManager>> {
+/// Initializes the kira audio manager with required settings.
+pub fn initialise_kira_audio_manager() -> Arc<Mutex<KiraManager>> {
     let audio_manager = AudioManager::<DefaultBackend>::new(AudioManagerSettings::default())
         .expect("failed to initialize audio manager");
-
-    Arc::new(Mutex::new(BackendStateManager {
+    Arc::new(Mutex::new(KiraManager {
         manager: audio_manager,
         instance_handle: None,
         volume: 0.0,
+        crossfade: false,
+        duration: None,
+    }))
+}
+
+/// Initializes the Rodio audio manager with required settings.
+pub fn initialise_rodio_audio_manager() -> Arc<Mutex<RodioManager>> {
+    Arc::new(Mutex::new(RodioManager::new()))
+}
+
+/// Initializes the AppAudioManager with required settings.
+pub fn initialize_audio_manager() -> Arc<Mutex<AppAudioManager>> {
+    // Create a Rodio device and get the output stream handle
+    Arc::new(Mutex::new(AppAudioManager {
         controls: None,
         cover_url: String::new(),
         port: 0,
@@ -38,9 +53,11 @@ pub fn setup_app(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>>
         mpsc::Receiver<MediaControlEvent>,
     ) = mpsc::channel(32);
     setup_macos::setup_macos(app)?;
-    let shared_audio_manager = Arc::clone(&app.state::<Arc<Mutex<BackendStateManager>>>());
+    let shared_audio_manager = Arc::clone(&app.state::<Arc<Mutex<AppAudioManager>>>());
     let shared_db_manager = Arc::clone(&app.state::<Arc<Mutex<DbManager>>>());
 
+    // setup audio manager
+
     // Set up the image route
     let cover_image_route = create_image_route_for_covers(shared_db_manager.clone());
     let image_route_with_uuid = create_image_route_with_uuid(shared_db_manager.clone());

muzik-offline/src-tauri/src/commands/general_commands.rs

@@ -1,5 +1,5 @@
 use crate::{
-    components::audio_manager::BackendStateManager,
+    components::audio_manager::AppAudioManager,
     utils::general_utils::{
         decode_image_in_parallel, encode_image_in_parallel, resize_and_compress_image,
     },
@@ -40,7 +40,7 @@ pub fn open_in_file_manager(file_path: &str) {
 }
 
 #[tauri::command]
-pub fn get_server_port(audio_manager: State<'_, Arc<Mutex<BackendStateManager>>>) -> u16 {
+pub fn get_server_port(audio_manager: State<'_, Arc<Mutex<AppAudioManager>>>) -> u16 {
     match audio_manager.lock() {
         Ok(audio_manager) => {
             return audio_manager.port;

muzik-offline/src-tauri/src/components/audio_manager.rs

@@ -1,14 +1,7 @@
-use kira::{
-    manager::{backend::DefaultBackend, AudioManager},
-    sound::{streaming::StreamingSoundHandle, FromFileError},
-};
 use souvlaki::MediaControls;
 
-pub struct BackendStateManager {
-    pub manager: AudioManager<DefaultBackend>,
-    pub instance_handle: Option<StreamingSoundHandle<FromFileError>>,
+pub struct AppAudioManager {
     pub controls: Option<MediaControls>,
-    pub volume: f64,
     pub cover_url: String,
     pub port: u16,
 }

muzik-offline/src-tauri/src/components/kira_audio_manager.rs

@@ -0,0 +1,12 @@
+use kira::{
+    manager::{backend::DefaultBackend, AudioManager},
+    sound::{streaming::StreamingSoundHandle, FromFileError},
+};
+
+pub struct KiraManager {
+    pub manager: AudioManager<DefaultBackend>,
+    pub instance_handle: Option<StreamingSoundHandle<FromFileError>>,
+    pub volume: f64,
+    pub crossfade: bool,
+    pub duration: Option<std::time::Duration>,
+}

muzik-offline/src-tauri/src/components/mod.rs

@@ -4,3 +4,5 @@ pub mod audio_manager;
 pub mod event_payload;
 pub mod genre;
 pub mod song;
+pub mod kira_audio_manager;
+pub mod rodio_audio_manager;

muzik-offline/src-tauri/src/components/rodio_audio_manager.rs

@@ -0,0 +1,101 @@
+use rodio::{OutputStream, Device, Sink};
+use std::sync::{Arc, Mutex};
+use std::sync::mpsc::{channel, Sender};
+use std::time::Duration;
+
+enum AudioCommand {
+    SetDevice(Device, Duration)
+}
+
+pub struct RodioManager {
+    sender: Sender<AudioCommand>,
+    pub sink: Arc<Mutex<Option<Sink>>>,
+    pub crossfade: bool,
+    pub duration: Option<Duration>,
+}
+
+impl RodioManager {
+    pub fn new() -> Self {
+        let (sender, receiver) = channel();
+        let sink: Arc<Mutex<Option<Sink>>> = Arc::new(Mutex::new(None));
+        let cloned_sink = sink.clone();
+
+        std::thread::spawn(move || {
+            // Initialize the default output stream
+            let (mut _current_stream, mut _current_handle) = OutputStream::try_default().expect("No default output stream available");
+            cloned_sink.lock().expect("unable to lock").replace(Sink::try_new(&_current_handle).expect("Failed to create sink"));
+
+            for command in receiver {
+                match command {
+                    AudioCommand::SetDevice(device, pos) => {
+                        if let Ok((new_stream, new_handle)) = OutputStream::try_from_device(&device) {
+                            let was_paused = match cloned_sink.lock(){
+                                Ok(mut sink) => {
+                                    match sink.as_mut(){
+                                        Some(sink) => {
+                                            sink.is_paused()
+                                        }
+                                        None => {
+                                            false
+                                        }
+                                    }
+                                }
+                                Err(_) => {
+                                    false
+                                }
+                            };
+
+                            _current_stream = new_stream;
+                            _current_handle = new_handle;
+                            match cloned_sink.lock(){
+                                Ok(mut sink) => {
+                                    match sink.as_mut(){
+                                        Some(sink) => {
+                                            match sink.try_seek(pos){
+                                                Ok(_) => {
+                                                    if !was_paused {
+                                                        sink.play();
+                                                    }
+                                                }
+                                                Err(_) => {
+                                                    eprintln!("Failed to seek sink");
+                                                }
+                                            }
+                                        }
+                                        None => {
+                                            eprintln!("Failed to lock sink");
+                                        }
+                                    }
+                                }
+                                Err(_) => {
+                                    eprintln!("Failed to lock sink");
+                                }
+                            }
+                            println!("Switched audio device successfully!");
+                        } else {
+                            eprintln!("Failed to switch audio device");
+                        }
+                    }
+                }
+            }
+        });
+
+        Self { 
+            sender,
+            sink: sink.clone(),
+            crossfade: false,
+            duration: None,
+        }
+    }
+
+    pub fn set_device(&self, device: Device, pos: Duration) {
+        match self.sender.send(AudioCommand::SetDevice(device, pos)){
+            Ok(_) => {
+
+            }
+            Err(_) => {
+
+            }
+        }
+    }
+}

muzik-offline/src-tauri/src/main.rs

@@ -23,6 +23,7 @@ use database::db_api::{
 use database::db_manager::DbManager;
 use export::{export_csv::export_songs_as_csv, export_html::export_songs_as_html, 
     export_json::export_songs_as_json,export_txt::export_songs_as_txt, export_xml::export_songs_as_xml};
+use music::player::set_playback_speed;
 //use export::export_pdf::export_songs_as_pdf;
 use socials::discord_rpc::{set_discord_rpc_activity_with_timestamps, DiscordRpc};
 use utils::music_list_organizer::MLO;
@@ -43,6 +44,7 @@ use crate::music::player::{
     get_song_position, load_a_song_from_path, load_and_play_song_from_path, pause_song,
     resume_playing, seek_by, seek_to, set_volume, stop_song,
 };
+use crate::music::rodio_player::{get_output_devices, set_output_device, get_default_output_device};
 use crate::socials::discord_rpc::{
     allow_connection_and_connect_to_discord_rpc, attempt_to_connect_if_possible,
     clear_discord_rpc_activity, disallow_connection_and_close_discord_rpc,
@@ -55,6 +57,8 @@ use crate::utils::music_list_organizer::{
 use app::setup::{
     setup_app,
     initialize_audio_manager,
+    initialise_kira_audio_manager,
+    initialise_rodio_audio_manager
 };
 
 fn main() {
@@ -73,6 +77,8 @@ fn main() {
             DiscordRpc::new().expect("failed to initialize discord rpc"),
         ))
         .manage(initialize_audio_manager())
+        .manage(initialise_kira_audio_manager())
+        .manage(initialise_rodio_audio_manager())
         .setup(setup_app)
         .invoke_handler(tauri::generate_handler![
             // WINDOW CONTROL
@@ -100,6 +106,10 @@ fn main() {
             seek_to,
             seek_by,
             get_song_position,
+            get_default_output_device,
+            get_output_devices,
+            set_output_device,
+            set_playback_speed,
             // UTILS
             resize_frontend_image_to_fixed_height,
             // MUSIC LIST ORGANIZER