init

src-tauri/src/lib.rs

@@ -0,0 +1,225 @@
+// Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
+use std::sync::Mutex;
+use std::time::{SystemTime, UNIX_EPOCH};
+use tauri::{Manager, Emitter};
+use tauri_plugin_deep_link::DeepLinkExt;
+
+// Store pending URLs that need to be handled when the window is ready
+static PENDING_URLS: Mutex<Vec<String>> = Mutex::new(Vec::new());
+
+mod api_client;
+mod auto_updater;
+mod browser;
+mod browser_runner;
+mod browser_version_service;
+mod default_browser;
+mod download;
+mod downloaded_browsers;
+mod extraction;
+mod proxy_manager;
+mod settings_manager;
+mod version_updater;
+
+extern crate lazy_static;
+
+use browser_runner::{
+  check_browser_status, create_browser_profile, create_browser_profile_new, delete_profile,
+  download_browser, fetch_browser_versions, fetch_browser_versions_cached_first,
+  fetch_browser_versions_detailed, fetch_browser_versions_with_count, fetch_browser_versions_with_count_cached_first,
+  get_cached_browser_versions_detailed, get_downloaded_browser_versions, get_saved_mullvad_releases, get_supported_browsers, is_browser_downloaded, check_browser_exists,
+  kill_browser_profile, launch_browser_profile, list_browser_profiles, rename_profile, should_update_browser_cache, update_profile_proxy,
+  update_profile_version,
+};
+
+use settings_manager::{
+  disable_default_browser_prompt, get_app_settings, save_app_settings,
+  should_show_settings_on_startup, get_table_sorting_settings, save_table_sorting_settings,
+};
+
+use default_browser::{is_default_browser, open_url_with_profile, set_as_default_browser, smart_open_url};
+
+use version_updater::{trigger_manual_version_update, get_version_update_status, get_version_updater, check_version_update_needed, force_version_update_check};
+
+use auto_updater::{
+  check_for_browser_updates, start_browser_update, complete_browser_update,
+  is_browser_disabled_for_update, dismiss_update_notification,
+  complete_browser_update_with_auto_update,
+  mark_auto_update_download, remove_auto_update_download, is_auto_update_download,
+};
+
+#[tauri::command]
+fn greet() -> String {
+  let now = SystemTime::now();
+  let epoch_ms = now.duration_since(UNIX_EPOCH).unwrap().as_millis();
+  format!("Hello world from Rust! Current epoch: {}", epoch_ms)
+}
+
+#[tauri::command]
+async fn handle_url_open(app: tauri::AppHandle, url: String) -> Result<(), String> {
+  println!("handle_url_open called with URL: {}", url);
+  
+  // Check if the main window exists and is ready
+  if let Some(window) = app.get_webview_window("main") {
+    if window.is_visible().unwrap_or(false) {
+      // Window is visible, emit event directly
+      println!("Main window is visible, emitting show-profile-selector event");
+      app.emit("show-profile-selector", url.clone())
+        .map_err(|e| format!("Failed to emit URL open event: {}", e))?;
+      let _ = window.show();
+      let _ = window.set_focus();
+    } else {
+      // Window not visible yet - add to pending URLs
+      println!("Main window not visible, adding URL to pending list");
+      let mut pending = PENDING_URLS.lock().unwrap();
+      pending.push(url);
+    }
+  } else {
+    // Window doesn't exist yet - add to pending URLs
+    println!("Main window doesn't exist, adding URL to pending list");
+    let mut pending = PENDING_URLS.lock().unwrap();
+    pending.push(url);
+  }
+  
+  Ok(())
+}
+
+#[tauri::command]
+async fn check_and_handle_startup_url(app_handle: tauri::AppHandle) -> Result<bool, String> {
+  let pending_urls = {
+    let mut pending = PENDING_URLS.lock().unwrap();
+    let urls = pending.clone();
+    pending.clear(); // Clear after getting them
+    urls
+  };
+  
+  if !pending_urls.is_empty() {
+    println!("Handling {} pending URLs from frontend request", pending_urls.len());
+    
+    for url in pending_urls {
+      println!("Emitting show-profile-selector event for URL: {}", url);
+      if let Err(e) = app_handle.emit("show-profile-selector", url.clone()) {
+        eprintln!("Failed to emit URL event: {}", e);
+        return Err(format!("Failed to emit URL event: {}", e));
+      }
+    }
+    
+    return Ok(true);
+  }
+  
+  Ok(false)
+}
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+  tauri::Builder::default()
+    .plugin(tauri_plugin_fs::init())
+    .plugin(tauri_plugin_opener::init())
+    .plugin(tauri_plugin_shell::init())
+    .plugin(tauri_plugin_deep_link::init())
+    .setup(|app| {
+      // Set up deep link handler
+      let handle = app.handle().clone();
+      
+      #[cfg(any(windows, target_os = "linux"))]
+      {
+        // For Windows and Linux, register all deep links at runtime for development
+        app.deep_link().register_all()?;
+      }
+      
+      // Handle deep links - this works for both scenarios:
+      // 1. App is running and URL is opened
+      // 2. App is not running and URL causes app to launch
+      app.deep_link().on_open_url({
+        let handle = handle.clone();
+        move |event| {
+          let urls = event.urls();
+          for url in urls {
+            let url_string = url.to_string();
+            println!("Deep link received: {}", url_string);
+            
+            // Clone the handle for each async task
+            let handle_clone = handle.clone();
+            
+            // Handle the URL asynchronously
+            tauri::async_runtime::spawn(async move {
+              if let Err(e) = handle_url_open(handle_clone, url_string.clone()).await {
+                eprintln!("Failed to handle deep link URL: {}", e);
+              }
+            });
+          }
+        }
+      });
+
+      // Initialize and start background version updater
+      let app_handle = app.handle().clone();
+      tauri::async_runtime::spawn(async move {
+        let version_updater = get_version_updater();
+        let mut updater_guard = version_updater.lock().await;
+        
+        // Set the app handle
+        updater_guard.set_app_handle(app_handle).await;
+        
+        // Start the background updates
+        updater_guard.start_background_updates().await;
+      });
+      
+      Ok(())
+    })
+    .invoke_handler(tauri::generate_handler![
+      greet,
+      get_supported_browsers,
+      download_browser,
+      delete_profile,
+      is_browser_downloaded,
+      check_browser_exists,
+      create_browser_profile_new,
+      create_browser_profile,          // Keep for backward compatibility
+      list_browser_profiles,
+      launch_browser_profile,
+      fetch_browser_versions,
+      fetch_browser_versions_detailed,
+      fetch_browser_versions_with_count,
+      fetch_browser_versions_cached_first,
+      fetch_browser_versions_with_count_cached_first,
+      get_cached_browser_versions_detailed,
+      should_update_browser_cache,
+      get_downloaded_browser_versions,
+      get_saved_mullvad_releases,
+      update_profile_proxy,
+      update_profile_version,
+      check_browser_status,
+      kill_browser_profile,
+      rename_profile,
+      // Settings commands
+      get_app_settings,
+      save_app_settings,
+      should_show_settings_on_startup,
+      disable_default_browser_prompt,
+      get_table_sorting_settings,
+      save_table_sorting_settings,
+      // Default browser commands
+      is_default_browser,
+      open_url_with_profile,
+      set_as_default_browser,
+      smart_open_url,
+      handle_url_open,
+      check_and_handle_startup_url,
+      // Version update commands
+      trigger_manual_version_update,
+      get_version_update_status,
+      check_version_update_needed,
+      force_version_update_check,
+      // Auto-update commands
+      check_for_browser_updates,
+      start_browser_update,
+      complete_browser_update,
+      is_browser_disabled_for_update,
+      dismiss_update_notification,
+      complete_browser_update_with_auto_update,
+      mark_auto_update_download,
+      remove_auto_update_download,
+      is_auto_update_download,
+    ])
+    .run(tauri::generate_context!())
+    .expect("error while running tauri application");
+}