Tenho seguinte código tauri rust v2

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;
use std::time::Instant;


#[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,
}

#[derive(Debug, Serialize, Clone)]
struct DownloadSpeed {
    speed: f64,
}

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);

  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;

  // Start timer
  let start_time = Instant::now();

  while let Some(chunk) = response.chunk().await? {
      file.write_all(&chunk)?;
      downloaded_bytes += chunk.len() as u64;

      // Calculate elapsed time
      let elapsed_time = start_time.elapsed().as_secs_f64(); // time in seconds
      let speed = if elapsed_time > 0.0 {
          downloaded_bytes as f64 / elapsed_time // speed in bytes/second
      } else {
          0.0
      };

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

      // Emit speed info
      app_handle.emit(
          "download_speed",
          DownloadSpeed {
              speed,
          },
      )?;
  }

  // Download completed
  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(())
}

As messages do emit estão acumulando por exemplo, primeiro exibe conectando ao servidor depois quando começa a baixar fica o seguinte Conectando ao servidor Baixando arquivo () ....