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> {
+lazy_static! {
-    tauri::plugin::Builder::new("clipboard")
+    static ref APP_DATA_DIR: Mutex<Option<std::path::PathBuf>> = Mutex::new(None);
-        .invoke_handler(tauri::generate_handler![
+}
-            read_image,
+
-            simulate_paste,
+pub fn set_app_data_dir(path: std::path::PathBuf) {
-            get_image_path
+    let mut dir = APP_DATA_DIR.lock().unwrap();
-        ])
+    *dir = Some(path);
-        .setup(|app_handle, _api| {
-            setup(app_handle.clone());
-            Ok(())
-        })
-        .build()
 }
 
 #[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 setup<R: Runtime>(app: &AppHandle<R>) {
-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>) {
     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! {
+#[tauri::command]
-    static ref APP_DATA_DIR: Mutex<Option<std::path::PathBuf>> = Mutex::new(None);
+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())?;
-pub fn set_app_data_dir(path: std::path::PathBuf) {
+    app_handle.emit("plugin:clipboard://clipboard-monitor/status", true).map_err(|e| e.to_string())?;
-    let mut dir = APP_DATA_DIR.lock().unwrap();
+    Ok(())
-    *dir = Some(path);
 }

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> {
+pub fn setup(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>> {
-    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>> {
     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> {
+use crate::utils::commands::center_window_on_current_monitor;
-    tauri::plugin::Builder::new("hotkeys")
-        .setup(|app, _| {
-            setup(app.app_handle().clone());
-            Ok(())
-        })
-        .build()
-}
 
-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::{
-use tauri::plugin::TauriPlugin;
+    Manager,
-use tauri::Manager;
+    menu::{MenuBuilder, MenuItemBuilder},
-use tauri::menu::{MenuBuilder, MenuItemBuilder};
+    tray::{MouseButton, TrayIconBuilder, TrayIconEvent},
-use tauri::tray::{MouseButton, TrayIconBuilder, TrayIconEvent};
+};
 
-pub fn init() -> TauriPlugin<tauri::Wry> {
+pub fn setup(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>> {
-    tauri::plugin::Builder::new("tray")
-        .setup(|app, _api| {
-            setup(app)?;
-            Ok(())
-        })
-        .build()
-}
-
-fn setup(app: &AppHandle) -> 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, async_runtime};
-use tauri::AppHandle;
 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(

src-tauri/src/main.rs

@@ -6,11 +6,12 @@
 mod api;
 mod utils;
 
-use tauri::{Manager, Listener};
+use tauri::Manager;
 use tauri_plugin_autostart::MacosLauncher;
 use tauri_plugin_prevent_default::Flags;
 
 fn main() {
+    #[allow(unused_variables)]
     tauri::Builder::default()
         .plugin(tauri_plugin_clipboard::init())
         .plugin(tauri_plugin_os::init())
@@ -21,11 +22,6 @@ fn main() {
             MacosLauncher::LaunchAgent,
             Some(vec![]),
         ))
-        .plugin(api::updater::init())
-        .plugin(api::database::init())
-        .plugin(api::tray::init())
-        .plugin(api::hotkeys::init())
-        .plugin(api::clipboard::init())
         .plugin(
             tauri_plugin_prevent_default::Builder::new()
                 .with_flags(Flags::all().difference(Flags::CONTEXT_MENU))
@@ -34,25 +30,32 @@ fn main() {
         .setup(|app| {
             let app_handle = app.handle().clone();
 
-            let app_data_dir = app
+            api::hotkeys::setup(app_handle.clone());
-                .path()
+            api::tray::setup(app)?;
-                .app_data_dir()
+            api::database::setup(app)?;
-                .expect("Failed to get app data directory");
+            api::clipboard::setup(app.handle());
-            api::clipboard::set_app_data_dir(app_data_dir);
+            let _ = api::clipboard::start_monitor(app_handle.clone());
 
             if let Some(window) = app.get_webview_window("main") {
                 utils::commands::center_window_on_current_monitor(&window);
                 window.hide().unwrap();
             }
 
-            let update_handle = app_handle.clone();
+            // #[cfg(dev)]
-            tauri::async_runtime::spawn(async move {
+            // {
-                api::updater::check_for_updates(update_handle).await;
+            //     let window = app.get_webview_window("main").unwrap();
-            });
+            //     window.open_devtools();
+            //     window.close_devtools();
+            // }
 
-            let monitor_handle = app_handle.clone();
+            let app_data_dir = app
-            app_handle.listen("database_initialized", move |_| {
+                .path()
-                let _ = api::clipboard::start_monitor(monitor_handle.clone());
+                .app_data_dir()
+                .expect("Failed to get app data directory");
+            api::clipboard::set_app_data_dir(app_data_dir);
+
+            tauri::async_runtime::spawn(async move {
+                api::updater::check_for_updates(app_handle).await;
             });
 
             Ok(())