@bghitcode/bghitapp 1.0.0

package/src-tauri/src/lib.rs

@@ -0,0 +1,227 @@
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+mod app;
+mod util;
+
+use tauri::Manager;
+use tauri_plugin_window_state::Builder as WindowStatePlugin;
+use tauri_plugin_window_state::StateFlags;
+
+#[cfg(target_os = "macos")]
+use std::time::Duration;
+
+const WINDOW_SHOW_DELAY: u64 = 50;
+
+use app::{
+    invoke::{
+        clear_cache_and_restart, clear_dock_badge, close_splashscreen, download_file,
+        increment_dock_badge, send_notification, set_dock_badge, set_dock_badge_label,
+        update_theme_mode,
+    },
+    setup::{set_global_shortcut, set_system_tray},
+    window::{build_splash_window, open_additional_window_safe, set_window, MultiWindowState},
+};
+use util::get_bghitapp_config;
+
+pub fn run_app() {
+    #[cfg(target_os = "linux")]
+    {
+        if std::env::var("WEBKIT_DISABLE_DMABUF_RENDERER").is_err() {
+            std::env::set_var("WEBKIT_DISABLE_DMABUF_RENDERER", "1");
+        }
+        if std::env::var("WEBKIT_DISABLE_COMPOSITING_MODE").is_err() {
+            std::env::set_var("WEBKIT_DISABLE_COMPOSITING_MODE", "1");
+        }
+    }
+
+    let (bghitapp_config, tauri_config) = get_bghitapp_config();
+    let tauri_app = tauri::Builder::default();
+
+    let show_system_tray = bghitapp_config.show_system_tray();
+    let hide_on_close = bghitapp_config.windows[0].hide_on_close;
+    let activation_shortcut = bghitapp_config.windows[0].activation_shortcut.clone();
+    let init_fullscreen = bghitapp_config.windows[0].fullscreen;
+    let start_to_tray = bghitapp_config.windows[0].start_to_tray && show_system_tray; // Only valid when tray is enabled
+    let multi_instance = bghitapp_config.multi_instance;
+    let multi_window = bghitapp_config.multi_window;
+    let _enable_find = bghitapp_config.windows[0].enable_find;
+    let has_splash = !bghitapp_config.windows[0].splash.is_empty();
+    let splash_asset = bghitapp_config.windows[0].splash.clone();
+
+    let window_state_plugin = WindowStatePlugin::default()
+        .with_state_flags(if init_fullscreen {
+            StateFlags::FULLSCREEN
+        } else {
+            // Prevent flickering on the first open.
+            StateFlags::all() & !StateFlags::VISIBLE
+        })
+        .build();
+
+    #[allow(deprecated)]
+    let mut app_builder = tauri_app
+        .plugin(window_state_plugin)
+        .plugin(tauri_plugin_oauth::init())
+        .plugin(tauri_plugin_http::init())
+        .plugin(tauri_plugin_shell::init())
+        .plugin(tauri_plugin_notification::init())
+        .plugin(tauri_plugin_opener::init()); // Add this
+
+    // Only add single instance plugin if multiple instances are not allowed
+    if !multi_instance {
+        app_builder = app_builder.plugin(tauri_plugin_single_instance::init(
+            move |app, _args, _cwd| {
+                if multi_window {
+                    open_additional_window_safe(app);
+                } else if let Some(window) = app.get_webview_window("bghitapp") {
+                    let _ = window.unminimize();
+                    let _ = window.show();
+                    let _ = window.set_focus();
+                }
+            },
+        ));
+    }
+
+    app_builder
+        .invoke_handler(tauri::generate_handler![
+            download_file,
+            send_notification,
+            increment_dock_badge,
+            set_dock_badge,
+            set_dock_badge_label,
+            clear_dock_badge,
+            update_theme_mode,
+            clear_cache_and_restart,
+            close_splashscreen,
+        ])
+        .setup(move |app| {
+            app.manage(MultiWindowState::new(
+                bghitapp_config.clone(),
+                tauri_config.clone(),
+            ));
+
+            // --- Menu Construction Start ---
+            #[cfg(target_os = "macos")]
+            {
+                app::menu::set_app_menu(app.app_handle(), multi_window, _enable_find)?;
+
+                // Event Handling for Custom Menu Item
+                app.on_menu_event(move |app_handle, event| {
+                    app::menu::handle_menu_click(app_handle, event.id().as_ref());
+                });
+            }
+            // --- Menu Construction End ---
+
+            // Create splash window if configured
+            if has_splash {
+                let _splash = build_splash_window(app.app_handle(), &splash_asset)?;
+                let _ = _splash.show();
+
+                // 10-second splash timeout: if main window hasn't signaled ready, show it anyway
+                let app_handle = app.app_handle().clone();
+                tauri::async_runtime::spawn(async move {
+                    tokio::time::sleep(tokio::time::Duration::from_millis(10000)).await;
+                    if let Some(splash) = app_handle.get_webview_window("splash") {
+                        let _ = splash.destroy();
+                    }
+                    if let Some(main) = app_handle.get_webview_window("bghitapp") {
+                        let _ = main.show();
+                        let _ = main.set_focus();
+                    }
+                });
+            }
+
+            let window = set_window(app.app_handle(), &bghitapp_config, &tauri_config)?;
+            set_system_tray(
+                app.app_handle(),
+                show_system_tray,
+                &bghitapp_config.system_tray_path,
+                init_fullscreen,
+                multi_window,
+            )?;
+            set_global_shortcut(app.app_handle(), activation_shortcut, init_fullscreen)?;
+
+            // Show window after state restoration to prevent position flashing
+            // Unless start_to_tray is enabled or splash is configured (splash handles showing)
+            if !start_to_tray && !has_splash {
+                let window_clone = window.clone();
+                tauri::async_runtime::spawn(async move {
+                    tokio::time::sleep(tokio::time::Duration::from_millis(WINDOW_SHOW_DELAY)).await;
+                    let _ = window_clone.show();
+
+                    // Fixed: Linux fullscreen issue with virtual keyboard
+                    #[cfg(target_os = "linux")]
+                    {
+                        if init_fullscreen {
+                            let _ = window_clone.set_fullscreen(true);
+                            // Ensure webview maintains focus for input after fullscreen
+                            let _ = window_clone.set_focus();
+                        } else {
+                            // Fix: Ubuntu 24.04/GNOME window buttons non-functional until resize (#1122)
+                            // The window manager needs time to process the MapWindow event before
+                            // accepting focus requests. Without this, decorations remain non-interactive.
+                            tokio::time::sleep(tokio::time::Duration::from_millis(30)).await;
+                            let _ = window_clone.set_focus();
+                        }
+                    }
+                });
+            }
+
+            Ok(())
+        })
+        .on_window_event(move |_window, _event| {
+            if let tauri::WindowEvent::CloseRequested { api, .. } = _event {
+                if hide_on_close && _window.label() == "bghitapp" {
+                    // Hide window when hide_on_close is enabled (regardless of tray status)
+                    let window = _window.clone();
+                    tauri::async_runtime::spawn(async move {
+                        #[cfg(target_os = "macos")]
+                        {
+                            if window.is_fullscreen().unwrap_or(false) {
+                                let _ = window.set_fullscreen(false);
+                                tokio::time::sleep(Duration::from_millis(900)).await;
+                            }
+                        }
+                        #[cfg(target_os = "linux")]
+                        {
+                            if window.is_fullscreen().unwrap_or(false) {
+                                let _ = window.set_fullscreen(false);
+                                // Restore focus after exiting fullscreen to fix input issues
+                                let _ = window.set_focus();
+                            }
+                        }
+                        // On macOS, directly hide without minimize to avoid duplicate Dock icons
+                        #[cfg(not(target_os = "macos"))]
+                        let _ = window.minimize();
+                        let _ = window.hide();
+                    });
+                    api.prevent_close();
+                }
+                // If hide_on_close is false, allow normal close behavior
+                // This lets tauri-plugin-window-state save the window position and size
+            }
+        })
+        .build(tauri::generate_context!())
+        .unwrap_or_else(|error| {
+            eprintln!("[BghitApp] Fatal error while building Tauri application: {error}");
+            std::process::exit(1);
+        })
+        .run(|_app, _event| {
+            // Handle macOS dock icon click to reopen hidden window
+            #[cfg(target_os = "macos")]
+            if let tauri::RunEvent::Reopen {
+                has_visible_windows,
+                ..
+            } = _event
+            {
+                if !has_visible_windows {
+                    if let Some(window) = _app.get_webview_window("bghitapp") {
+                        let _ = window.show();
+                        let _ = window.set_focus();
+                    }
+                }
+            }
+        });
+}
+
+pub fn run() {
+    run_app()
+}

package/src-tauri/src/main.rs

@@ -0,0 +1,8 @@
+#![cfg_attr(
+    all(not(debug_assertions), target_os = "windows"),
+    windows_subsystem = "windows"
+)]
+
+fn main() {
+    app_lib::run()
+}

package/src-tauri/src/util.rs

@@ -0,0 +1,245 @@
+use crate::app::config::BghitappConfig;
+use std::env;
+use std::path::{Path, PathBuf};
+use tauri::{AppHandle, Config, Manager, WebviewWindow};
+
+pub fn get_bghitapp_config() -> (BghitappConfig, Config) {
+    #[cfg(feature = "cli-build")]
+    let bghitapp_config: BghitappConfig = serde_json::from_str(include_str!("../.bghitapp/bghitapp.json"))
+        .expect("Failed to parse bghitapp config");
+
+    #[cfg(not(feature = "cli-build"))]
+    let bghitapp_config: BghitappConfig =
+        serde_json::from_str(include_str!("../bghitapp.json")).expect("Failed to parse bghitapp config");
+
+    #[cfg(feature = "cli-build")]
+    let tauri_config: Config = serde_json::from_str(include_str!("../.bghitapp/tauri.conf.json"))
+        .expect("Failed to parse tauri config");
+
+    #[cfg(not(feature = "cli-build"))]
+    let tauri_config: Config = serde_json::from_str(include_str!("../tauri.conf.json"))
+        .expect("Failed to parse tauri config");
+
+    (bghitapp_config, tauri_config)
+}
+
+pub fn get_data_dir(app: &AppHandle, package_name: String) -> std::io::Result<PathBuf> {
+    let data_dir = app
+        .path()
+        .config_dir()
+        .map_err(|err| {
+            std::io::Error::new(
+                std::io::ErrorKind::NotFound,
+                format!("Failed to resolve config dir: {err}"),
+            )
+        })?
+        .join(package_name);
+
+    if !data_dir.exists() {
+        std::fs::create_dir_all(&data_dir).map_err(|err| {
+            std::io::Error::new(
+                err.kind(),
+                format!("Can't create dir {}: {err}", data_dir.display()),
+            )
+        })?;
+    }
+
+    Ok(data_dir)
+}
+
+pub fn show_toast(window: &WebviewWindow, message: &str) {
+    let script = format!(r#"bghitappToast("{message}");"#);
+    if let Err(error) = window.eval(&script) {
+        eprintln!("[BghitApp] Failed to show toast: {error}");
+    }
+}
+
+pub enum MessageType {
+    Start,
+    Success,
+    Failure,
+}
+
+pub fn get_download_message_with_lang(
+    message_type: MessageType,
+    language: Option<String>,
+) -> String {
+    let default_start_message = "Start downloading~";
+    let chinese_start_message = "开始下载中~";
+
+    let default_success_message = "Download successful, saved to download directory~";
+    let chinese_success_message = "下载成功，已保存到下载目录~";
+
+    let default_failure_message = "Download failed, please check your network connection~";
+    let chinese_failure_message = "下载失败，请检查你的网络连接~";
+
+    let is_chinese = language
+        .as_ref()
+        .map(|lang| {
+            lang.starts_with("zh")
+                || lang.contains("CN")
+                || lang.contains("TW")
+                || lang.contains("HK")
+        })
+        .unwrap_or_else(|| {
+            // Try multiple environment variables for better system detection
+            ["LANG", "LC_ALL", "LC_MESSAGES", "LANGUAGE"]
+                .iter()
+                .find_map(|var| env::var(var).ok())
+                .map(|lang| {
+                    lang.starts_with("zh")
+                        || lang.contains("CN")
+                        || lang.contains("TW")
+                        || lang.contains("HK")
+                })
+                .unwrap_or(false)
+        });
+
+    if is_chinese {
+        match message_type {
+            MessageType::Start => chinese_start_message,
+            MessageType::Success => chinese_success_message,
+            MessageType::Failure => chinese_failure_message,
+        }
+    } else {
+        match message_type {
+            MessageType::Start => default_start_message,
+            MessageType::Success => default_success_message,
+            MessageType::Failure => default_failure_message,
+        }
+    }
+    .to_string()
+}
+
+/// Check if the file exists. If it does, append `-N` to the stem until a free
+/// path is found.
+///
+/// Robustness notes:
+/// - Files without an extension are handled (we keep them extensionless).
+/// - If the numeric suffix would overflow `u32::MAX` we fall back to the
+///   original file_path so the caller never enters an infinite loop on
+///   pathologically large filenames (regression guard for #1183).
+pub fn check_file_or_append(file_path: &str) -> String {
+    let mut new_path = PathBuf::from(file_path);
+
+    while new_path.exists() {
+        let file_stem = new_path
+            .file_stem()
+            .map(|s| s.to_string_lossy().to_string())
+            .unwrap_or_default();
+        let extension = new_path
+            .extension()
+            .map(|e| e.to_string_lossy().to_string());
+        let parent_dir = new_path.parent().unwrap_or(Path::new(""));
+
+        let parsed_suffix = file_stem.rfind('-').and_then(|index| {
+            file_stem[index + 1..]
+                .parse::<u32>()
+                .ok()
+                .map(|n| (index, n))
+        });
+
+        let new_file_stem = match parsed_suffix {
+            Some((index, current)) => {
+                let Some(next) = current.checked_add(1) else {
+                    // u32::MAX collisions are a sign of something pathological;
+                    // bail with the original path instead of looping forever.
+                    return file_path.to_string();
+                };
+                let base_name = &file_stem[..index];
+                format!("{base_name}-{next}")
+            }
+            None => format!("{file_stem}-1"),
+        };
+
+        new_path = match &extension {
+            Some(ext) => parent_dir.join(format!("{new_file_stem}.{ext}")),
+            None => parent_dir.join(new_file_stem),
+        };
+    }
+
+    new_path.to_string_lossy().into_owned()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::env;
+    use std::fs;
+    use std::path::PathBuf;
+
+    fn temp_path(name: &str) -> PathBuf {
+        let mut dir = env::temp_dir();
+        dir.push(format!(
+            "bghitapp-util-test-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .map(|d| d.as_nanos())
+                .unwrap_or(0)
+        ));
+        fs::create_dir_all(&dir).unwrap();
+        dir.push(name);
+        dir
+    }
+
+    #[test]
+    fn check_file_or_append_returns_input_when_missing() {
+        let path = temp_path("ghost.txt");
+        let resolved = check_file_or_append(path.to_str().unwrap());
+        assert_eq!(resolved, path.to_string_lossy());
+        let _ = fs::remove_dir_all(path.parent().unwrap());
+    }
+
+    #[test]
+    fn check_file_or_append_increments_suffix() {
+        let path = temp_path("dup.txt");
+        fs::write(&path, b"existing").unwrap();
+        let resolved = check_file_or_append(path.to_str().unwrap());
+        assert!(resolved.ends_with("dup-1.txt"), "got {resolved}");
+        let _ = fs::remove_dir_all(path.parent().unwrap());
+    }
+
+    #[test]
+    fn check_file_or_append_handles_files_without_extension() {
+        let path = temp_path("README");
+        fs::write(&path, b"existing").unwrap();
+        let resolved = check_file_or_append(path.to_str().unwrap());
+        assert!(resolved.ends_with("README-1"), "got {resolved}");
+        let _ = fs::remove_dir_all(path.parent().unwrap());
+    }
+
+    #[test]
+    fn check_file_or_append_does_not_panic_on_huge_suffix() {
+        let path = temp_path(&format!("huge-{}.txt", u32::MAX));
+        fs::write(&path, b"existing").unwrap();
+        let resolved = check_file_or_append(path.to_str().unwrap());
+        assert!(resolved.contains("huge-"));
+        let _ = fs::remove_dir_all(path.parent().unwrap());
+    }
+
+    #[test]
+    fn download_message_falls_back_to_english_for_unknown_locale() {
+        let msg = get_download_message_with_lang(MessageType::Start, Some("fr-FR".to_string()));
+        assert_eq!(msg, "Start downloading~");
+    }
+
+    #[test]
+    fn download_message_picks_chinese_for_zh_locales() {
+        for tag in ["zh", "zh-CN", "zh-TW", "en-CN", "en-HK"] {
+            let msg = get_download_message_with_lang(MessageType::Success, Some(tag.to_string()));
+            assert_eq!(
+                msg, "下载成功，已保存到下载目录~",
+                "expected Chinese for {tag}"
+            );
+        }
+    }
+
+    #[test]
+    fn download_message_failure_localized() {
+        let en = get_download_message_with_lang(MessageType::Failure, Some("en".into()));
+        let zh = get_download_message_with_lang(MessageType::Failure, Some("zh".into()));
+        assert!(en.contains("Download failed"));
+        assert!(zh.contains("下载失败"));
+    }
+}

package/src-tauri/tauri.conf.json

@@ -0,0 +1,20 @@
+{
+  "productName": "BghitApp",
+  "identifier": "com.bghitcode.bghitapp",
+  "version": "1.0.0",
+  "app": {
+    "withGlobalTauri": true,
+    "trayIcon": {
+      "iconPath": "png/weekly_512.png",
+      "iconAsTemplate": false,
+      "id": "bghitapp-tray"
+    },
+    "security": {
+      "headers": {},
+      "csp": null
+    }
+  },
+  "build": {
+    "frontendDist": "../dist"
+  }
+}

package/src-tauri/tauri.linux.conf.json

@@ -0,0 +1,12 @@
+{
+  "bundle": {
+    "icon": ["png/weekly_512.png"],
+    "active": true,
+    "linux": {
+      "deb": {
+        "depends": ["curl", "wget"]
+      }
+    },
+    "targets": ["deb", "appimage"]
+  }
+}

package/src-tauri/tauri.macos.conf.json

@@ -0,0 +1,28 @@
+{
+  "bundle": {
+    "icon": ["icons/weekly.icns"],
+    "active": true,
+    "targets": ["dmg"],
+    "macOS": {
+      "signingIdentity": "-",
+      "hardenedRuntime": true,
+      "entitlements": "entitlements.plist",
+      "infoPlist": "Info.plist",
+      "dmg": {
+        "background": "assets/macos/dmg/background.png",
+        "windowSize": {
+          "width": 680,
+          "height": 420
+        },
+        "appPosition": {
+          "x": 190,
+          "y": 250
+        },
+        "applicationFolderPosition": {
+          "x": 500,
+          "y": 250
+        }
+      }
+    }
+  }
+}

package/src-tauri/tauri.windows.conf.json

@@ -0,0 +1,15 @@
+{
+  "bundle": {
+    "icon": ["png/weekly_256.ico", "png/weekly_32.ico"],
+    "active": true,
+    "resources": ["png/weekly_32.ico"],
+    "targets": ["msi"],
+    "windows": {
+      "digestAlgorithm": "sha256",
+      "wix": {
+        "language": ["en-US"],
+        "template": "assets/main.wxs"
+      }
+    }
+  }
+}