tenho seguinte código tauri v2 rust


use serde::{Deserialize, Serialize};
use std::{
    fs::{self, File},
    io::{self, Write},
    path::{Path, PathBuf},
};

use tauri::{AppHandle, Emitter}; // Importando a trait Emitter
use reqwest::Client;

#[derive(Debug, Deserialize)]
struct PatchEntry {
    //version: u32,
    file_name: String,
    //target: String,
    //integrity: String,
}

#[derive(Debug, Serialize, Clone)]
struct DownloadMessage {
    message: String,
}

#[derive(Debug, Serialize, Clone)]
struct DownloadInfo {
    current_file: usize,
    total_files: usize,
    file_name: String,
    downloaded_bytes: u64,
    total_bytes: u64,
}

fn get_exe_dir() -> PathBuf {
    std::env::current_exe()
        .unwrap()
        .parent()
        .unwrap()
        .to_path_buf()
}

fn read_patch_file(path: &Path) -> io::Result<Vec<PatchEntry>> {
    let file = File::open(path)?;
    let patches: Vec<PatchEntry> = serde_json::from_reader(file)?;
    Ok(patches)
}

async fn download_file(
  app_handle: &AppHandle,
  client: &Client,
  entry: PatchEntry,
  download_dir: &Path,
  current_file: usize,
  total_files: usize,
) -> Result<(), Box<dyn std::error::Error>> {
  let url = format!("https://hil-speed.hetzner.com/{}", entry.file_name);
  let file_path = download_dir.join(&entry.file_name);

  // Emitindo um evento de início do download
  /*app_handle.emit(
      "download_message",
      DownloadMessage {
          message: "Iniciando download".to_string(),
      },
  )?;*/

  let mut response = client.get(&url).send().await?;
  let total_bytes = response.content_length().unwrap_or(0);
  let mut file = File::create(&file_path)?;

  let mut downloaded_bytes = 0;

  // Lendo o corpo da resposta
  while let Some(chunk) = response.chunk().await? {
      file.write_all(&chunk)?;
      downloaded_bytes += chunk.len() as u64;

      app_handle.emit(
        "download_message",
        DownloadMessage {
            message: "Baixando".to_string(),
        },
      )?;

      app_handle.emit(
          "download_info",
          DownloadInfo {
              current_file,
              total_files,
              file_name: entry.file_name.clone(),
              downloaded_bytes,
              total_bytes,
          },
      )?;
  }

  // Download concluído
  app_handle.emit(
      "download_message",
      DownloadMessage {
          message: "Download concluído".to_string(),
      },
  )?;

  Ok(())
}

async fn check_server_connection(client: &Client, url: &str) -> Result<(), Box<dyn std::error::Error>> {
  let response = client.get(url).send().await?;
  if response.status().is_success() {
      Ok(())
  } else {
      Err("Failed to connect to the server".into())
  }
}

#[tauri::command]
pub async fn start_downloads(app_handle: AppHandle) -> Result<(), String> {
    let exe_dir = get_exe_dir();
    let patch_file_path = exe_dir.join("patch.json");
    let download_dir = exe_dir.join("patchs");

    if !download_dir.exists() {
        fs::create_dir_all(&download_dir).map_err(|e| e.to_string())?;
    }

    let patches = read_patch_file(&patch_file_path).map_err(|e| e.to_string())?;
    let client = Client::new();
    let total_files = patches.len();

    app_handle.emit(
        "download_message",
        DownloadMessage {
            message: "Conectando ao servidor...".to_string(),
        },
    ).map_err(|e| e.to_string())?;

    // Verifique a conexão com o servidor
    let server_url = "https://hil-speed.hetzner.com/";
    if let Err(err) = check_server_connection(&client, server_url).await {
        app_handle.emit(
            "download_message",
            DownloadMessage {
                message: format!("Erro ao conectar ao servidor: {}", err),
            },
        ).map_err(|e| e.to_string())?;
        return Err(format!("Erro ao conectar ao servidor: {}", err));
    }

    // Estabelecimento da conexão
    app_handle.emit(
        "download_message",
        DownloadMessage {
            message: "Conexão estabelecida com sucesso. Iniciando download...".to_string(),
        },
    ).map_err(|e| e.to_string())?;

    for (current_file, entry) in patches.into_iter().enumerate() {
        let current_file = current_file + 1; // Índice baseado em 1
        if let Err(err) = download_file(&app_handle, &client, entry, &download_dir, current_file, total_files).await {
            eprintln!("Erro ao baixar arquivo: {}", err);
        }
    }

    Ok(())
}

Escreva um emit da velocidade de download que está baixando os arquivos e print o valor no react