hololake-system-architecture/product-source/hololake-native-desktop/src-tauri/src/lib.rs

mod circular_lake_membrane;
mod code_channel;
mod code_repo_login;
mod direct_local_broker;
mod direct_local_session;
mod dynamic_capability_routing;
mod glp_envelope;
mod home_status;
mod knowledge_base;
mod local_development_bridge;
mod personal_channel;
mod pncc_receipt_projection;
mod pncc_remote_git;
mod pncc_repository_binding;
mod pncc_server_projection;
mod release_trust;
mod release_update;
mod user_pncc_channel;
mod zero_point;

use tauri::Manager;

pub fn run_connector() -> Result<(), String> {
    direct_local_broker::run_connector()
}

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_dialog::init())
        .invoke_handler(tauri::generate_handler![
            home_status::get_hololake_home_status,
            release_update::check_hololake_update,
            release_update::confirm_hololake_update_install,
            release_update::get_hololake_release_recovery_status,
            release_update::confirm_hololake_release_health,
            release_update::rollback_hololake_update,
            direct_local_session::issue_direct_local_discovery_ticket,
            direct_local_session::open_direct_local_session,
            direct_local_session::resume_direct_local_session,
            direct_local_session::append_direct_local_session_event,
            direct_local_broker::get_nearby_ai_discovery,
            local_development_bridge::acquire_development_write_lane,
            local_development_bridge::inspect_development_write_lane,
            local_development_bridge::release_development_write_lane,
            personal_channel::get_personal_channel_snapshot,
            personal_channel::initialize_personal_channel,
            personal_channel::create_personal_channel_task,
            personal_channel::transition_personal_channel_task,
            knowledge_base::get_knowledge_snapshot,
            knowledge_base::read_knowledge_document,
            knowledge_base::search_knowledge,
            knowledge_base::save_knowledge_document,
            knowledge_base::select_and_import_knowledge_folder,
            knowledge_base::export_knowledge_document,
            knowledge_base::create_knowledge_document,
            knowledge_base::delete_knowledge_document,
            knowledge_base::delete_knowledge_folder,
            knowledge_base::print_knowledge_document,
            code_channel::get_code_channel_snapshot,
            code_channel::clone_code_channel,
            code_channel::select_local_code_channel,
            code_channel::browse_code_channel,
            code_channel::read_code_channel_file,
            pncc_repository_binding::inspect_mounted_pncc_repository,
            pncc_repository_binding::select_pncc_repository_candidate,
            pncc_repository_binding::confirm_pncc_repository_mount,
            pncc_receipt_projection::query_pncc_receipt_projection,
            pncc_server_projection::query_jd_pncc_server_projection,
            code_repo_login::check_code_repo_login,
            code_repo_login::perform_code_repo_login,
            code_repo_login::sign_out_code_repo_login,
            user_pncc_channel::get_user_pncc_channel,
            user_pncc_channel::ensure_user_pncc_channel,
            zero_point::zero_point_bind,
            zero_point::zero_point_verify,
            zero_point::zero_point_sync,
            zero_point::zero_point_status,
        ])
        .setup(|app| {
            // 初始化零点原核客户端运行时；该系统层不等同人格主体或模型载体。
            let zero_point_state = zero_point::ZeroPointState::default();
            if let Err(error) = zero_point::boot_zero_point(app.handle(), &zero_point_state) {
                eprintln!("HoloLake zero-point core requires maintenance: {error}");
            }
            app.manage(zero_point_state);
            let zero_point_handle = app.handle().clone();
            tauri::async_runtime::spawn(async move {
                let state = zero_point_handle.state::<zero_point::ZeroPointState>();
                if let Err(error) = zero_point::sync_protocol_runtime(&state).await {
                    eprintln!("HoloLake zero-point protocol sync was not completed: {error}");
                }
            });
            let broker = direct_local_broker::start(app.handle())?;
            app.manage(broker);
            release_trust::install_updater_if_provisioned(app.handle())?;
            if let Err(error) = release_update::observe_release_startup(app.handle()) {
                eprintln!("HoloLake update recovery requires maintenance: {error}");
            }
            // 根据主显示器尺寸调整窗口，并将位置限制在可见区域内。
            if let Some(window) = app.get_webview_window("main") {
                let monitor = window
                    .primary_monitor()
                    .ok()
                    .flatten()
                    .or_else(|| window.current_monitor().ok().flatten());
                if let Some(monitor) = monitor {
                    let physical = monitor.size();
                    let scale = monitor.scale_factor().max(1.0);
                    let width = ((physical.width as f64 / scale) * 0.82).clamp(960.0, 1600.0);
                    let height = ((physical.height as f64 / scale) * 0.82).clamp(640.0, 1000.0);
                    let _ = window.set_size(tauri::LogicalSize::new(width, height));
                    // 使用主显示器坐标计算居中位置，避免多显示器环境下窗口移出可见区域。
                    let mon_pos = monitor.position();
                    let x =
                        mon_pos.x as f64 / scale + ((physical.width as f64 / scale) - width) / 2.0;
                    let y = mon_pos.y as f64 / scale
                        + ((physical.height as f64 / scale) - height) / 2.0;
                    let _ =
                        window.set_position(tauri::LogicalPosition::new(x.max(0.0), y.max(0.0)));
                }
            }
            Ok(())
        })
        .run(tauri::generate_context!())
        .expect("failed to run HoloLake native desktop");
}