Function run

src/apps/desktop/src/lib.rs:211–1306

()

/// Tauri application entry point
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub async fn run() {
    let startup_started = Instant::now();
    let startup_trace_id = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|duration| format!("desktop-{}", duration.as_millis()))
        .unwrap_or_else(|_| "desktop-unknown".to_string());
    let startup_trace = DesktopStartupTrace::new(startup_trace_id.clone(), startup_started);
    startup_trace.record_phase("native_process_start", "native");
    let mut startup_timings = TimingCollector::default();
    let in_debug = cfg!(debug_assertions) || std::env::var("DEBUG").unwrap_or_default() == "1";
    let log_config = logging::LogConfig::new(in_debug);
    let log_targets = logging::build_log_targets(&log_config);
    let session_log_dir = log_config.session_log_dir.clone();
    crash_diagnostics::initialize_run_state(session_log_dir.clone(), &startup_trace_id);
    setup_panic_hook();

    // Install the rustls ring CryptoProvider as the process-level default early,
    // so that all subsequent TLS operations (relay_client, reqwest, tokio-tungstenite)
    // reuse the same provider instead of each attempting their own install_default().
    // This is a no-op on non-Windows platforms where tokio-tungstenite handles it.
    bitfun_core::service::remote_connect::ensure_rustls_crypto_provider();

    eprintln!("=== BitFun Desktop Starting ===");

    let step_started = Instant::now();
    if let Err(e) = bitfun_core::service::config::initialize_global_config().await {
        log::error!("Failed to initialize global config service: {}", e);
        return;
    }
    startup_timings.record_elapsed("initialize_global_config", step_started);
    startup_trace.record_elapsed_step("native_pre_tauri", "initialize_global_config", step_started);

    // Initialize global I18nService so bot/remote-connect language is always in sync.
    {
        use bitfun_core::service::config::get_global_config_service;
        use bitfun_core::service::i18n::initialize_global_i18n_service;
        let step_started = Instant::now();
        match get_global_config_service().await {
            Ok(config_service) => {
                if let Err(e) = initialize_global_i18n_service(Some(config_service)).await {
                    log::error!("Failed to initialize global I18nService: {}", e);
                }
            }
            Err(e) => {
                log::error!("Failed to get config service for I18nService init: {}", e);
            }
        }
        startup_timings.record_elapsed("initialize_global_i18n_service", step_started);
        startup_trace.record_elapsed_step(
            "native_pre_tauri",
            "initialize_global_i18n_service",
            step_started,
        );
    }

    let step_started = Instant::now();
    let startup_log_level = resolve_runtime_log_level(log_config.level).await;
    startup_trace.record_elapsed_step(