clash-proxy/src-tauri/src/cmd/proxy.rs

use super::CmdResult;
use crate::{core::handle, module::mihomo::MihomoManager, state::proxy::CmdProxyState};
use std::{
    sync::Mutex,
    time::{Duration, Instant},
};
use tauri::Manager;

const PROVIDERS_REFRESH_INTERVAL: Duration = Duration::from_secs(3);

#[tauri::command]
pub async fn get_proxies() -> CmdResult<serde_json::Value> {
    let manager = MihomoManager::global();

    manager
        .refresh_proxies()
        .await
        .map(|_| manager.get_proxies())
        .or_else(|_| Ok(manager.get_proxies()))
}

#[tauri::command]
pub async fn get_providers_proxies() -> CmdResult<serde_json::Value> {
    let app_handle = handle::Handle::global().app_handle().unwrap();
    let cmd_proxy_state = app_handle.state::<Mutex<CmdProxyState>>();

    let should_refresh = {
        let mut state = cmd_proxy_state.lock().unwrap();
        let now = Instant::now();
        if now.duration_since(state.last_refresh_time) > PROVIDERS_REFRESH_INTERVAL {
            state.need_refresh = true;
            state.last_refresh_time = now;
        }
        state.need_refresh
    };

    if should_refresh {
        let manager = MihomoManager::global();
        if let Err(e) = manager.refresh_providers_proxies().await {
            log::warn!(target: "app", "providers_proxies刷新失败: {}", e);
            return Err(e.into());
        }

        let mut state = cmd_proxy_state.lock().unwrap();
        state.providers_proxies = manager.get_providers_proxies().clone();
        state.need_refresh = false;
        log::debug!(target: "app", "providers_proxies刷新成功");
    }

    let providers_proxies = {
        let state = cmd_proxy_state.lock().unwrap();
        state.providers_proxies.clone()
    };
    Ok(providers_proxies)
}