diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 3dc30ea..9ddc126 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -42,11 +42,11 @@ pub async fn run() {
         .plugin(tauri_plugin_decorum::init())
         .setup(|app| {
             let state = state::AppData::new(AppDataNew { db, stream_handle });
-            app.manage(state.clone());
+            app.manage(state);
 
             if cfg!(target_os = "macos") {
                 #[cfg(target_os = "macos")]
-                macos_interop::now_playing::setup_handlers(state.clone());
+                macos_interop::now_playing::setup_handlers(state);
             }
 
             let main_window = app.get_webview_window("main").unwrap();
diff --git a/src-tauri/src/macos_interop/now_playing.rs b/src-tauri/src/macos_interop/now_playing.rs
index 118aa2c..44e3693 100644
--- a/src-tauri/src/macos_interop/now_playing.rs
+++ b/src-tauri/src/macos_interop/now_playing.rs
@@ -7,31 +7,32 @@ use objc2_media_player::{
     MPNowPlayingInfoPropertyAssetURL, MPNowPlayingInfoPropertyIsLiveStream,
     MPNowPlayingInfoPropertyMediaType, MPNowPlayingPlaybackState,
 };
+use tauri::State;
 
-pub fn setup_handlers(state: crate::state::AppData) {
+pub fn setup_handlers(mut state: State<'static, crate::state::AppData>) {
     unsafe {
         let shared = objc2_media_player::MPRemoteCommandCenter::sharedCommandCenter();
-        let state_clone1 = state.clone();
+        let state_clone = state.clone();
         let play_handler = block2::StackBlock::new(
             move |_: core::ptr::NonNull<objc2_media_player::MPRemoteCommandEvent>| {
-                crate::music::core::resume(&state_clone1);
+                crate::music::core::resume(&state_clone);
                 objc2_media_player::MPRemoteCommandHandlerStatus::Success
             },
         );
-        let state_clone2 = state.clone();
+        let state_clone = state.clone();
         let pause_handler = block2::StackBlock::new(
             move |_: core::ptr::NonNull<objc2_media_player::MPRemoteCommandEvent>| {
-                crate::music::core::pause(&state_clone2);
+                crate::music::core::pause(&state_clone);
                 objc2_media_player::MPRemoteCommandHandlerStatus::Success
             },
         );
-        let state_clone3 = state.clone();
+        let state_clone = state.clone();
         let toggle_play_pause_handler = block2::StackBlock::new(
             move |_: core::ptr::NonNull<objc2_media_player::MPRemoteCommandEvent>| {
-                if crate::music::core::is_playing(&state_clone3) {
-                    crate::music::core::pause(&state_clone3);
+                if crate::music::core::is_playing(&state_clone) {
+                    crate::music::core::pause(&state_clone);
                 } else {
-                    crate::music::core::resume(&state_clone3);
+                    crate::music::core::resume(&state_clone);
                 }
                 objc2_media_player::MPRemoteCommandHandlerStatus::Success
             },
diff --git a/src-tauri/src/music/commands.rs b/src-tauri/src/music/commands.rs
index 46c9bdc..e75c264 100644
--- a/src-tauri/src/music/commands.rs
+++ b/src-tauri/src/music/commands.rs
@@ -27,7 +27,7 @@ pub fn play(app: AppHandle, path: &str, state: State<'_, AppData>) -> Result<(),
         app_handle
             .emit(
                 "PLAYBACK_POSITION_UPDATE",
-                app_handle.state::<AppData>().sink.lock().unwrap().get_pos(),
+                app_handle.state::<AppData>().sink.get_pos(),
             )
             .unwrap();
     });
diff --git a/src-tauri/src/music/core.rs b/src-tauri/src/music/core.rs
index 834629a..3528e5d 100644
--- a/src-tauri/src/music/core.rs
+++ b/src-tauri/src/music/core.rs
@@ -35,7 +35,7 @@ pub async fn import_file(app_data: &AppData, path: &str) -> Result<(), String> {
         path: Set(path.parse().unwrap()),
         ..Default::default()
     }
-    .save(app_data.db.as_ref())
+    .save(&app_data.db)
     .await
     .map(|_| ())
     .map_err(|e| e.to_string())
@@ -133,51 +133,51 @@ pub fn play_audio(
     // Periodic access is closed when the sink is stopped (Is this correct?)
     let periodic_access = source.periodic_access(Duration::from_secs(1), on_periodic);
 
-    app_data.sink.lock().unwrap().clear();
-    app_data.sink.lock().unwrap().append(periodic_access);
+    app_data.sink.clear();
+    app_data.sink.append(periodic_access);
 
     Ok(duration)
 }
 
 pub fn stop(app_data: &AppData) {
-    app_data.sink.lock().unwrap().stop();
+    app_data.sink.stop();
 }
 
 pub fn set_volume(app_data: &AppData, volume: f32) {
-    app_data.sink.lock().unwrap().set_volume(volume);
+    app_data.sink.set_volume(volume);
 }
 
 pub fn set_speed(app_data: &AppData, speed: f32) {
-    app_data.sink.lock().unwrap().set_speed(speed);
+    app_data.sink.set_speed(speed);
 }
 
 pub fn seek_to(app_data: &AppData, position: std::time::Duration) -> Result<(), String> {
-    app_data.sink.lock().unwrap().try_seek(position).map_err(|e| e.to_string())
+    app_data.sink.try_seek(position).map_err(|e| e.to_string())
 }
 
 pub fn pause(app_data: &AppData) {
-    app_data.sink.lock().unwrap().pause();
+    app_data.sink.pause();
 }
 
 pub fn is_playing(app_data: &AppData) -> bool {
-    !app_data.sink.lock().unwrap().is_paused()
+    !app_data.sink.is_paused()
 }
 
 pub fn resume(app_data: &AppData) {
-    app_data.sink.lock().unwrap().play();
+    app_data.sink.play();
 }
 
 pub fn get_player_state(app_data: &AppData) -> PlayerState {
     let metadata = app_data.metadata.lock().unwrap();
     PlayerState {
-        volume: app_data.sink.lock().unwrap().volume(),
-        speed: app_data.sink.lock().unwrap().speed(),
-        paused: app_data.sink.lock().unwrap().is_paused(),
+        volume: app_data.sink.volume(),
+        speed: app_data.sink.speed(),
+        paused: app_data.sink.is_paused(),
         currently_playing_file_path: metadata.currently_playing_file_path.clone(),
         currently_playing_duration: metadata.currently_playing_duration.clone(),
     }
 }
 
 pub fn get_position(app_data: &AppData) -> std::time::Duration {
-    app_data.sink.lock().unwrap().get_pos()
+    app_data.sink.get_pos()
 }
diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rs
index efb512c..1a4deea 100644
--- a/src-tauri/src/state.rs
+++ b/src-tauri/src/state.rs
@@ -1,18 +1,17 @@
 use rodio::{OutputStreamHandle, Sink};
 use sea_orm::DatabaseConnection;
-use std::sync::{Arc, Mutex};
+use std::sync::Mutex;
 
-#[derive(Clone)]
 pub struct AppMetadata {
     pub currently_playing_file_path: Option<String>,
     pub currently_playing_duration: Option<std::time::Duration>,
 }
 
 pub struct AppData {
-    pub metadata: Arc<Mutex<AppMetadata>>,
-    pub stream_handle: Arc<OutputStreamHandle>,
-    pub sink: Arc<Mutex<Sink>>,
-    pub db: Arc<DatabaseConnection>,
+    pub metadata: Mutex<AppMetadata>,
+    pub stream_handle: OutputStreamHandle,
+    pub sink: Sink,
+    pub db: DatabaseConnection,
 }
 
 pub struct AppDataNew {
@@ -26,24 +25,13 @@ impl AppData {
         let sink: Sink = Sink::try_new(&stream_handle).unwrap();
 
         Self {
-            db: Arc::new(db),
-            metadata: Arc::new(Mutex::new(AppMetadata {
+            db,
+            metadata: Mutex::new(AppMetadata {
                 currently_playing_duration: None,
                 currently_playing_file_path: None,
-            })),
-            sink: Arc::new(Mutex::new(sink)),
-            stream_handle: Arc::new(stream_handle),
-        }
-    }
-}
-
-impl Clone for AppData {
-    fn clone(&self) -> Self {
-        Self {
-            metadata: self.metadata.clone(),
-            stream_handle: self.stream_handle.clone(),
-            sink: self.sink.clone(),
-            db: self.db.clone(),
+            }),
+            sink,
+            stream_handle,
         }
     }
 }