Tauri Rust 一些前后交互通信方式和全局变量

Invoke - 暴露端点方式进行交互

在Rust中，使用 “Invoke_hander” 暴露一个方法，在前端引入Invoke，就可以直接调用并且获取返回结果

// 创建一个handle_infoke_fn的方法，并且返回一个字符串
fn expose_fn(_str:String)->String{ 
    let _res_str = format!("接受参数为{}",_str);
    _res_str 
}

import { invoke } from '@tauri-apps/api/tauri'; 
// 同步的方式 
const handle_invoke_handler=async (str)=>{ 
    try { 
        let res = await invoke("expose_fn", { _str: str, });
        return res 
    } catch (error) { 
        return error 
    } 
} 
    
 // 异步方式 
 const handle_invoke_handler=async (str)=>{ 
     return invoke("expose_fn", { _str: str, }) 
 }

emit / listen 数据监听的方式

注意：emit的名字不能和listen监听名字相同

fn main(){
    extern crate serde;
    extern crate serde_json;
    use tauri::Manager;
    tauri::Builder::default()
            .setup(|app| {
                let window: tauri::Window = app.get_window("main").unwrap();
                let _win = app.get_window("main").unwrap();
                window.listen("point_code", move |event: tauri::Event| {
                    if let Some(data) = event.clone().payload() {
                        let _jsons=serde_json::from_str(data).expect("No JSON")
                        _win.emit("res_point_code",_jsons)
                    } else {
                        println!("Event data is empty");
                    }
                });
                Ok(())
            })
            .invoke_handler(tauri::generate_handler![])
            .run(tauri::generate_context!())
            .expect("error while running tauri application");
}

import { emit } from '@tauri-apps/api/event';
import { listen } from '@tauri-apps/api/event';
const sendPointCode=()=>{
    let _json={age:1};
    emit("point_code",_json)
}
const linstenPoinCode=(callback)=>{
    const unlisten = await listen('res_point_code', (event) => {
      console.log(`Got error in window ${event.windowLabel}, payload: ${event.payload}`);
      callback(event.payload)
   });
   return unlisten
}

使用Lazy创建全局变量

use once_cell::sync::Lazy;
use parking_lot::Mutex;
pub static GLOBAL_VALUE: Lazy<Mutex<bool>> = Lazy::new(|| Mutex::new(false));
fn change_global_value(){
    // 因为使用的是Mutex的方式，但是这个方式有个弊端
    // Mutex<T>  MutexGuard<T>  运行时可能会死锁，可能会阻塞线程
    // 解释也就是Mutex是一种互斥锁，通常用于保证多个线程不会同时访问共享数据。
    // 而MutexGuard 是一个智能指针，超出作用域时会自动释放锁
    // 所以创建新的进程来进行赋值，这样在进程结束的时候 自动解锁；
    let handle= thread::spawn(move||{
        let mut _global_value=GLOBAL_VALUE.lock();
        *_global_value=false    
    })
    handle.join().unwrap()
}
fn use_global_value(){
    let  _global_value=GLOBAL_VALUE.lock();
    println!("global_value:{}",*_global_value);
    // 结束当前函数作用域时自动解锁
}

使用TCP创建客户端连接

// 创建TCP 客户端
use once_cell::sync::Lazy;
use std::sync::{Arc, Mutex};
use std::{thread, time::Duration};
use std::io::Read;

/*
byteorder = "1.5.0"
once_cell = "1.18.0"
parking_lot = "0.12.1"
*/


pub static KEY_STREAM: Lazy<Arc<Mutex<TcpStream>>> = Lazy::new(|| {
    let listener = TcpStream::connect("127.0.0.1:8888").expect("连接失败");
    let steam = Mutex::new(listener);
    return Arc::new(steam);
});
pub static IS_CLOSE: Lazy<Mutex<bool>> = Lazy::new(|| Mutex::new(true));

fn handle_buffer(buffer: [u8; 184]) -> Vec<f32> {
    let mut numbers: Vec<f32> = Vec::new();
    for i in (0..184).step_by(4) {
        // 使用字节操作来将每 4 个字节解释为一个 f32 数字
        let num_bytes: [u8; 4] = [buffer[i], buffer[i + 1], buffer[i + 2], buffer[i + 3]];
        // 使用 from_le_bytes 或 from_be_bytes 来将字节数组转换为 f32 数字，取决于字节顺序
        let num = f32::from_be_bytes(num_bytes); // 或者 from_be_bytes 根据需要选择字节顺序

        numbers.push(num);
    }
    numbers
}
//循环读取TCP数据
fn get_connect_msg(){
     let _handle = thread::spawn(move || {
        let mut stream = KEY_STREAM.lock().unwrap();
        let steams = &mut *stream;
        loop {
            thread::sleep(Duration::from_millis(100));
            // 通过判断是否关闭来退出循环
            let _is_close = IS_CLOSE.lock().unwrap();
            if *_is_close == true {
                break;
            }
            let mut buffer: [u8; 184] = [0; 184];
            //读取server发过来的内容
            steams.read(&mut buffer).unwrap();
            let data = handle_buffer(buffer);
        }
    });
    // 这儿不能使用_handle.join，使用会释放这个线程
}
fn un_listener(){
     let mut stream = KEY_STREAM.lock().unwrap();
     // 文档是写的关闭读取和写入， 但没有尝试过
     stream.shutdown(Shutdown::Both)
}