darkwing/server/services/browser_profile_services/config/

media_devices.rs

//! Media devices configuration module for browser profiles.
//!
//! This module handles the configuration of media devices like speakers,
//! microphones, and webcameras for browser profiles. It supports both automatic
//! and manual mode configuration of these devices.

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

use super::{FromStartRequest, Navigator, Screen};

/// Configuration for browser media devices.
///
/// Represents the state and configuration of media devices including speakers,
/// microphones, and webcameras. Each device has an associated count and names
/// for identification.
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
pub struct MediaDevices {
  /// Number of audio output (speaker) devices
  pub(super) speaker: u8,
  /// Number of audio input (microphone) devices
  pub(super) microphone: u8,
  /// Number of video input (webcamera) devices
  pub(super) webcamera: u8,
  /// Name identifier for the microphone device
  pub(super) microphone_name: String,
  /// Name identifier for the webcamera device
  pub(super) webcamera_name: String,
}

/// Implementation of conversion from start request for MediaDevices.
impl FromStartRequest<MediaDevices> for MediaDevices {
  /// Creates a MediaDevices configuration from a browser profile and start
  /// request.
  ///
  /// # Arguments
  ///
  /// * `bp` - Browser profile containing media device settings
  /// * `_request` - Start request parameters (unused)
  /// * `_navigator` - Navigator configuration (unused)
  /// * `_screen` - Screen configuration (unused)
  /// * `_token` - Authentication token (unused)
  ///
  /// # Returns
  ///
  /// Returns a Result containing the configured MediaDevices or an Error
  fn from_start_request(
    bp: &BrowserProfileFullData,
    _request: &StartRequest,
    _navigator: &Navigator,
    _screen: &Screen,
    _token: &str,
  ) -> Result<Self, Error> {
    let speaker = if bp.media_devices.mode == Mode::Manual {
      bp.media_devices.audio_outputs
    } else {
      0
    };

    let microphone = if bp.media_devices.mode == Mode::Manual {
      bp.media_devices.audio_inputs
    } else {
      0
    };

    let webcamera = if bp.media_devices.mode == Mode::Manual {
      bp.media_devices.video_inputs
    } else {
      0
    };

    Ok(Self {
      speaker,
      microphone,
      webcamera,
      microphone_name: "".to_string(),
      webcamera_name: "".to_string(),
    })
  }
}

/// Test module for MediaDevices functionality
#[cfg(test)]
mod tests {
  use super::*;
  use crate::server::services::browser_profile_services::config::consts::LINUX_MOCK_PROFILE;

  /// Creates a base browser profile for testing with default media device
  /// settings
  fn create_base_profile() -> BrowserProfileFullData {
    BrowserProfileFullData {
      media_devices: crate::server::dtos::browser_profile_dto::MediaDevices {
        mode: Mode::Auto,
        audio_inputs: 0,
        audio_outputs: 0,
        video_inputs: 0,
      },
      ..LINUX_MOCK_PROFILE.clone()
    }
  }

  /// Creates a base start request for testing
  fn create_base_request() -> StartRequest {
    StartRequest::get_mock()
  }

  #[test]
  fn test_manual_mode_with_devices() -> Result<(), Error> {
    let mut profile = create_base_profile();
    profile.media_devices.mode = Mode::Manual;
    profile.media_devices.audio_outputs = 2;
    profile.media_devices.audio_inputs = 1;
    profile.media_devices.video_inputs = 1;

    let request = create_base_request();
    let navigator = Navigator::default();
    let screen = Screen::default();
    let token = String::new();

    let result = MediaDevices::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    assert_eq!(result.speaker, 2);
    assert_eq!(result.microphone, 1);
    assert_eq!(result.webcamera, 1);
    assert_eq!(result.microphone_name, "");
    assert_eq!(result.webcamera_name, "");
    Ok(())
  }

  #[test]
  fn test_auto_mode_no_devices() -> Result<(), Error> {
    let profile = create_base_profile();
    let request = create_base_request();
    let navigator = Navigator::default();
    let screen = Screen::default();
    let token = String::new();

    let result = MediaDevices::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    assert_eq!(result.speaker, 0);
    assert_eq!(result.microphone, 0);
    assert_eq!(result.webcamera, 0);
    assert_eq!(result.microphone_name, "");
    assert_eq!(result.webcamera_name, "");
    Ok(())
  }

  #[test]
  fn test_manual_mode_zero_devices() -> Result<(), Error> {
    let mut profile = create_base_profile();
    profile.media_devices.mode = Mode::Manual;
    // Explicitly set all devices to 0
    profile.media_devices.audio_outputs = 0;
    profile.media_devices.audio_inputs = 0;
    profile.media_devices.video_inputs = 0;

    let request = create_base_request();
    let navigator = Navigator::default();
    let screen = Screen::default();
    let token = String::new();

    let result = MediaDevices::from_start_request(
      &profile, &request, &navigator, &screen, &token,
    )?;

    assert_eq!(result.speaker, 0);
    assert_eq!(result.microphone, 0);
    assert_eq!(result.webcamera, 0);
    assert_eq!(result.microphone_name, "");
    assert_eq!(result.webcamera_name, "");
    Ok(())
  }
}