darkwing/server/services/browser_profile_services/config/

voices.rs

//! Configuration for text-to-speech voices and speech synthesis
//!
//! This module handles configuration of available text-to-speech voices based
//! on the platform (Windows, macOS, Linux) and locale settings. It provides
//! structs and implementations for managing voice settings and capabilities.

use crate::{
  database::browser_profile::Platform,
  server::{
    dtos::{
      browser_profile_dto::BrowserProfileFullData, start_dto::StartRequest,
    },
    error::Error,
  },
};
use serde::{Deserialize, Serialize};

use super::{
  consts::{MACOS_VOICES, WINDOWS_VOICES},
  screen::Screen,
  FromStartRequest, Navigator,
};

/// Configuration for a single text-to-speech voice
///
/// Contains the language and name of a voice that can be used for speech
/// synthesis.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
pub struct Voice {
  #[serde(rename = "lang")]
  pub(super) language: String,
  pub(super) name: String,
}

/// Collection of available text-to-speech voices
///
/// Wraps a vector of Voice structs representing all available voices for the
/// current platform and locale configuration.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
pub struct Voices(pub Vec<Voice>);

/// Creates voice configuration from browser profile and start request data
///
/// Filters available voices based on:
/// - Platform (Windows, macOS, Linux)
/// - Navigator locale
/// - Special handling for en-US and en locales
impl FromStartRequest<Voices> for Voices {
  fn from_start_request(
    bp: &BrowserProfileFullData,
    _request: &StartRequest,
    navigator: &Navigator,
    _screen: &Screen,
    _token: &str,
  ) -> Result<Self, Error> {
    let locale = navigator.locale.clone();

    let voices = match bp.platform {
      Platform::Windows => WINDOWS_VOICES
        .iter()
        .copied()
        .filter(|voice| {
          voice.0.to_lowercase() == locale.clone().to_lowercase() // TODO(@araratbakaryan): differs from macos impl
            || voice.0.to_lowercase() == "en-US".to_string().to_lowercase()
        })
        .collect(),
      Platform::Macos => MACOS_VOICES
        .iter()
        .copied()
        .filter(|voice| {
          voice.0.to_lowercase() != locale.clone().to_lowercase()  // TODO(@araratbakaryan): differs from windows impl
            || voice.0.to_lowercase() == "en-US".to_string().to_lowercase()
            || voice.0.to_lowercase() == "en".to_string().to_lowercase()
        })
        .collect(),
      Platform::Linux => Vec::new(),
    };

    let voices = voices
      .into_iter()
      .map(|voice| Voice {
        language: voice.0.to_string(),
        name: voice.1.to_string(),
      })
      .collect();

    Ok(Self(voices))
  }
}

/// Configuration for speech synthesis capabilities
///
/// Controls whether speech synthesis is enabled and manages the collection
/// of available voices.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
pub struct SpeechVoices {
  pub(super) enabled: bool,
  pub(super) voices: Voices,
}

/// Creates speech synthesis configuration from browser profile and start
/// request data
///
/// Currently always sets enabled to false while preserving the voice
/// configuration.
impl FromStartRequest<SpeechVoices> for SpeechVoices {
  fn from_start_request(
    bp: &BrowserProfileFullData,
    request: &StartRequest,
    navigator: &Navigator,
    screen: &Screen,
    token: &str,
  ) -> Result<Self, Error> {
    Ok(SpeechVoices {
      enabled: false,
      voices: Voices::from_start_request(
        bp, request, navigator, screen, token,
      )?,
    })
  }
}

#[cfg(test)]
mod tests {
  use super::*;
  use crate::server::services::browser_profile_services::config::consts::LINUX_MOCK_PROFILE;

  fn create_base_profile() -> BrowserProfileFullData {
    LINUX_MOCK_PROFILE.clone()
  }

  fn create_navigator(locale: &str) -> Navigator {
    Navigator {
      locale: locale.to_string(),
      ..Navigator::default()
    }
  }

  #[test]
  fn test_windows_voices() -> Result<(), Error> {
    let mut profile = create_base_profile();
    profile.platform = Platform::Windows;
    let request = StartRequest::get_mock();
    let navigator = create_navigator("en-US");
    let screen = Screen::default();
    let token = String::new();

    let voices = Voices::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    // Windows should include voices matching the locale and en-US
    let voices = voices.0;
    assert!(!voices.is_empty());
    assert!(voices.iter().any(|v| v.language == "en-US"));
    Ok(())
  }

  #[test]
  fn test_windows_voices_non_english() -> Result<(), Error> {
    let mut profile = create_base_profile();
    profile.platform = Platform::Windows;
    let request = StartRequest::get_mock();
    let navigator = create_navigator("en-CA");
    let screen = Screen::default();
    let token = String::new();

    let voices = Voices::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    let voices = voices.0;
    assert!(!voices.is_empty());
    // Should include both en-CA and en-US voices
    assert!(voices.iter().any(|v| v.language == "en-CA"));
    assert!(voices.iter().any(|v| v.language == "en-US"));
    Ok(())
  }

  #[test]
  fn test_macos_voices() -> Result<(), Error> {
    let mut profile = create_base_profile();
    profile.platform = Platform::Macos;
    let request = StartRequest::get_mock();
    let navigator = create_navigator("en-US");
    let screen = Screen::default();
    let token = String::new();

    let voices = Voices::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    let voices = voices.0;
    assert!(!voices.is_empty());
    assert!(voices.iter().any(|v| v.language == "en-US"));
    Ok(())
  }

  #[test]
  fn test_macos_voices_non_english() -> Result<(), Error> {
    let mut profile = create_base_profile();
    profile.platform = Platform::Macos;
    let request = StartRequest::get_mock();
    let navigator = create_navigator("fr-FR");
    let screen = Screen::default();
    let token = String::new();

    let voices = Voices::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    let voices = voices.0;
    assert!(!voices.is_empty());
    // macOS implementation differs from Windows - it includes voices that
    // don't match the locale (except en-US)
    assert!(voices.iter().any(|v| v.language == "en-US"));
    Ok(())
  }

  #[test]
  fn test_linux_voices() -> Result<(), Error> {
    let profile = create_base_profile(); // Already Linux platform
    let request = StartRequest::get_mock();
    let navigator = create_navigator("en-US");
    let screen = Screen::default();
    let token = String::new();

    let voices = Voices::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    // Linux should have no voices
    assert!(voices.0.is_empty());
    Ok(())
  }

  #[test]
  fn test_voice_structure() -> Result<(), Error> {
    let mut profile = create_base_profile();
    profile.platform = Platform::Windows;
    let request = StartRequest::get_mock();
    let navigator = create_navigator("en-US");
    let screen = Screen::default();
    let token = String::new();

    let voices = Voices::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    // Check that voices have both language and name fields populated
    for voice in voices.0 {
      assert!(!voice.language.is_empty());
      assert!(!voice.name.is_empty());
    }
    Ok(())
  }
}