back to normal setup methods

src-tauri/src/api/clipboard.rs

@@ -1,6 +1,6 @@
 use base64::Engine;
 use base64::engine::general_purpose::STANDARD;
-use tauri::{AppHandle, Manager, Emitter, Listener};
+use tauri::{AppHandle, Manager, Runtime, Emitter, Listener};
 use tauri_plugin_clipboard::Clipboard;
 use tokio::runtime::Runtime as TokioRuntime;
 use regex::Regex;
@@ -16,20 +16,14 @@ use sha2::{Sha256, Digest};
 use rdev::{simulate, Key, EventType};
 use lazy_static::lazy_static;
 use image::ImageFormat;
-use tauri::plugin::TauriPlugin;
 
-pub fn init() -> TauriPlugin<tauri::Wry> {
-    tauri::plugin::Builder::new("clipboard")
-        .invoke_handler(tauri::generate_handler![
-            read_image,
-            simulate_paste,
-            get_image_path
-        ])
-        .setup(|app_handle, _api| {
-            setup(app_handle.clone());
-            Ok(())
-        })
-        .build()
+lazy_static! {
+    static ref APP_DATA_DIR: Mutex<Option<std::path::PathBuf>> = Mutex::new(None);
+}
+
+pub fn set_app_data_dir(path: std::path::PathBuf) {
+    let mut dir = APP_DATA_DIR.lock().unwrap();
+    *dir = Some(path);
 }
 
 #[tauri::command]
@@ -64,15 +58,7 @@ pub fn get_image_path(app_handle: tauri::AppHandle, filename: String) -> String
     image_path.to_str().unwrap_or("").to_string()
 }
 
-#[tauri::command]
-pub fn start_monitor(app_handle: tauri::AppHandle) -> Result<(), String> {
-    let clipboard = app_handle.state::<Clipboard>();
-    clipboard.start_monitor(app_handle.clone()).map_err(|e| e.to_string())?;
-    app_handle.emit("plugin:clipboard://clipboard-monitor/status", true).map_err(|e| e.to_string())?;
-    Ok(())
-}
-
-fn setup<R: tauri::Runtime>(app: AppHandle<R>) {
+pub fn setup<R: Runtime>(app: &AppHandle<R>) {
     let app = app.clone();
     let runtime = TokioRuntime::new().expect("Failed to create Tokio runtime");
 
@@ -124,14 +110,14 @@ fn setup<R: tauri::Runtime>(app: AppHandle<R>) {
     });
 }
 
-async fn get_pool<R: tauri::Runtime>(app_handle: &tauri::AppHandle<R>) -> Result<SqlitePool, Box<dyn std::error::Error + Send + Sync>> {
+async fn get_pool<R: Runtime>(app_handle: &AppHandle<R>) -> Result<SqlitePool, Box<dyn std::error::Error + Send + Sync>> {
     let app_data_dir = app_handle.path().app_data_dir().expect("Failed to get app data directory");
     let db_path = app_data_dir.join("data.db");
     let database_url = format!("sqlite:{}", db_path.to_str().unwrap());
     SqlitePool::connect(&database_url).await.map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)
 }
 
-async fn insert_content_if_not_exists<R: tauri::Runtime>(app_handle: tauri::AppHandle<R>, pool: SqlitePool, content_type: &str, content: String) {
+async fn insert_content_if_not_exists<R: Runtime>(app_handle: AppHandle<R>, pool: SqlitePool, content_type: &str, content: String) {
     let last_content: Option<String> = sqlx::query_scalar(
         "SELECT content FROM history WHERE content_type = ? ORDER BY timestamp DESC LIMIT 1",
     )
@@ -191,7 +177,7 @@ async fn insert_content_if_not_exists<R: tauri::Runtime>(app_handle: tauri::AppH
     }
 }
 
-async fn save_image<R: tauri::Runtime>(app_handle: &tauri::AppHandle<R>, base64_image: &str) -> Result<String, Box<dyn std::error::Error>> {
+async fn save_image<R: Runtime>(app_handle: &AppHandle<R>, base64_image: &str) -> Result<String, Box<dyn std::error::Error>> {
     let image_data = STANDARD.decode(base64_image)?;
     let mut hasher = Sha256::new();
     hasher.update(&image_data);
@@ -226,11 +212,10 @@ async fn fetch_favicon_as_base64(url: url::Url) -> Result<Option<String>, Box<dy
     }
 }
 
-lazy_static! {
-    static ref APP_DATA_DIR: Mutex<Option<std::path::PathBuf>> = Mutex::new(None);
-}
-
-pub fn set_app_data_dir(path: std::path::PathBuf) {
-    let mut dir = APP_DATA_DIR.lock().unwrap();
-    *dir = Some(path);
+#[tauri::command]
+pub fn start_monitor(app_handle: AppHandle) -> Result<(), String> {
+    let clipboard = app_handle.state::<Clipboard>();
+    clipboard.start_monitor(app_handle.clone()).map_err(|e| e.to_string())?;
+    app_handle.emit("plugin:clipboard://clipboard-monitor/status", true).map_err(|e| e.to_string())?;
+    Ok(())
 }

src-tauri/src/api/database.rs

@@ -1,21 +1,11 @@
-use tauri::plugin::TauriPlugin;
-use tauri::{AppHandle, Manager, Emitter};
 use sqlx::sqlite::SqlitePoolOptions;
 use std::fs;
 use tokio::runtime::Runtime;
+use tauri::Manager;
 use rand::{thread_rng, Rng};
 use rand::distributions::Alphanumeric;
 
-pub fn init() -> TauriPlugin<tauri::Wry> {
-    tauri::plugin::Builder::new("database")
-        .setup(|app_handle: &AppHandle, _api| {
-            setup(app_handle)?;
-            Ok(())
-        })
-        .build()
-}
-
-fn setup(app: &AppHandle) -> Result<(), Box<dyn std::error::Error>> {
+pub fn setup(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>> {
     let rt = Runtime::new().expect("Failed to create Tokio runtime");
 
     let app_data_dir = app.path().app_data_dir().unwrap();
@@ -76,7 +66,5 @@ fn setup(app: &AppHandle) -> Result<(), Box<dyn std::error::Error>> {
     app.manage(pool);
     app.manage(rt);
 
-    app.emit("database_initialized", ()).expect("Failed to emit database_initialized event");
-
     Ok(())
 }

src-tauri/src/api/hotkeys.rs

@@ -1,18 +1,9 @@
-use tauri::plugin::TauriPlugin;
-use tauri::Manager;
 use rdev::{listen, EventType, Key};
-use crate::utils::commands;
+use tauri::Manager;
 
-pub fn init() -> TauriPlugin<tauri::Wry> {
-    tauri::plugin::Builder::new("hotkeys")
-        .setup(|app, _| {
-            setup(app.app_handle().clone());
-            Ok(())
-        })
-        .build()
-}
+use crate::utils::commands::center_window_on_current_monitor;
 
-fn setup(app_handle: tauri::AppHandle) {
+pub fn setup(app_handle: tauri::AppHandle) {
     std::thread::spawn(move || {
         let mut meta_pressed = false;
         listen(move |event| {
@@ -29,7 +20,7 @@ fn setup(app_handle: tauri::AppHandle) {
                         let window = app_handle.get_webview_window("main").unwrap();
                         window.show().unwrap();
                         window.set_focus().unwrap();
-                        commands::center_window_on_current_monitor(&window);
+                        center_window_on_current_monitor(&window);
                     }
                 }
                 _ => {}

src-tauri/src/api/tray.rs

@@ -1,19 +1,10 @@
-use tauri::AppHandle;
-use tauri::plugin::TauriPlugin;
-use tauri::Manager;
-use tauri::menu::{MenuBuilder, MenuItemBuilder};
-use tauri::tray::{MouseButton, TrayIconBuilder, TrayIconEvent};
+use tauri::{
+    Manager,
+    menu::{MenuBuilder, MenuItemBuilder},
+    tray::{MouseButton, TrayIconBuilder, TrayIconEvent},
+};
 
-pub fn init() -> TauriPlugin<tauri::Wry> {
-    tauri::plugin::Builder::new("tray")
-        .setup(|app, _api| {
-            setup(app)?;
-            Ok(())
-        })
-        .build()
-}
-
-fn setup(app: &AppHandle) -> Result<(), Box<dyn std::error::Error>> {
+pub fn setup(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>> {
     let window = app.get_webview_window("main").unwrap();
     let window_clone_for_tray = window.clone();
     let window_clone_for_click = window.clone();

src-tauri/src/api/updater.rs

@@ -1,16 +1,8 @@
-use tauri::plugin::TauriPlugin;
-use tauri::AppHandle;
+use tauri::{AppHandle, async_runtime};
 use tauri_plugin_dialog::{DialogExt, MessageDialogKind};
 use tauri_plugin_updater::UpdaterExt;
-use tokio;
 
-pub fn init() -> TauriPlugin<tauri::Wry> {
-    tauri::plugin::Builder::new("updater")
-        .invoke_handler(tauri::generate_handler![check_for_updates])
-        .build()
-}
 
-#[tauri::command]
 pub async fn check_for_updates(app: AppHandle) {
     println!("Checking for updates...");
 
@@ -36,7 +28,7 @@ pub async fn check_for_updates(app: AppHandle) {
                     if !response {
                         return;
                     }
-                    tokio::spawn(async move {
+                    async_runtime::spawn(async move {
                         if let Err(e) = update.download_and_install(|_, _| {}, || {}).await {
                             println!("Error installing new update: {:?}", e);
                             app.dialog().message(
@@ -51,4 +43,4 @@ pub async fn check_for_updates(app: AppHandle) {
             println!("Failed to check for updates: {:?}", e);
         }
     }
-}
+}