# How Meetily Handles Audio Device Discovery and Enumeration > Discover how Meetily handles audio device discovery and enumeration using CPAL. Learn about platform-specific hosts, AudioDevice structs, and permission prompts on macOS and Windows. - Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily) - Tags: how-to-guide - Published: 2026-07-28 --- **Meetily leverages the cross-platform CPAL library to enumerate audio devices through platform-specific hosts, returning strongly-typed `AudioDevice` structs while managing permission prompts on macOS and Windows.** The open-source video conferencing application Meetily (Zackriya-Solutions/meetily) implements a robust audio subsystem to handle the complexities of hardware enumeration across operating systems. Its approach to audio device discovery and enumeration centers on the **CPAL** (Cross-Platform Audio Library) crate, abstracting away OS-specific APIs while preserving granular control over device classification and permission handling. ## The Discovery Architecture Audio device discovery in Meetily is centralized in **[`frontend/src-tauri/src/audio/devices/discovery.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/discovery.rs)**. The system follows a multi-phase pipeline that balances cross-platform consistency with OS-specific optimizations. **Creating the Host** The process begins by instantiating the default audio host using `cpal::default_host()`. This function returns a platform-specific implementation: WASAPI on Windows, ALSA or PulseAudio on Linux, and CoreAudio/ScreenCaptureKit on macOS. This host object serves as the factory for all subsequent device enumeration. ## Platform-Specific Device Configuration After obtaining the host, Meetily delegates to platform-specific configuration functions located in **`frontend/src-tauri/src/audio/devices/platform/`**: - **`configure_windows_audio`** (Windows): Handles WASAPI-specific device properties and default endpoint detection - **`configure_linux_audio`** (Linux): Manages ALSA/PulseAudio device prioritization - **`configure_macos_audio`** (macOS): Integrates with CoreAudio and ScreenCaptureKit for system audio capture These helpers construct a `Vec` containing preferred input and output devices, including default microphones and system capture interfaces. Each function understands the idiosyncrasies of its target platform, ensuring that primary devices appear first in the enumeration list. ## Device Classification and Enumeration Device type definitions reside in **[`frontend/src-tauri/src/audio/devices/configuration.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/configuration.rs)**. The **`AudioDevice`** struct encapsulates device metadata including the display name and **`DeviceType`** classification (`Input`, `Output`, or `System`). **Complete Host Enumeration** Following platform-specific configuration, the discovery routine iterates over `host.devices()` to capture any remaining hardware not already added: ```rust // Simplified logic from discovery.rs let mut devices = configure_platform_specific(&host); for device in host.devices()? { if !already_present(&device, &devices) { devices.push(AudioDevice { name: device.name()?, device_type: DeviceType::Output, // Default classification }); } } ``` This two-phase approach guarantees that every device reported by CPAL appears in Meetily’s device list, while prioritizing platform-preferred hardware at the top of the enumeration. ## Audio Permission Handling on Restricted Platforms Modern operating systems require explicit user consent before accessing microphones. Meetily handles this through **`trigger_audio_permission()`** in the discovery module. The function constructs a minimal input stream using the default input device, starts it briefly, and sleeps to trigger the OS permission dialog: ```rust pub fn trigger_audio_permission() -> Result { let host = cpal::default_host(); let device = host.default_input_device().ok_or(...)?; let config = device.default_input_config()?; let stream = device.build_input_stream( &config.into(), |_| {}, // Empty callback |_| {}, // Error callback None )?; stream.play()?; std::thread::sleep(std::time::Duration::from_millis(100)); Ok(true) } ``` This technique works on both macOS and Windows, providing immediate feedback on whether the user has granted microphone access without requiring a full application initialization. ## Integration with the Tauri Frontend The discovery layer exposes asynchronous Tauri commands that the frontend invokes to populate device selection dropdowns. The **`list_audio_devices`** function is marked `pub async` because some platform callbacks may yield asynchronously, though the core enumeration logic remains synchronous once the host is available. **Enumerating Devices:** ```rust use crate::audio::devices::discovery::list_audio_devices; #[tauri::command] async fn get_audio_devices() -> Result, String> { list_audio_devices() .await .map_err(|e| format!("Failed to enumerate devices: {}", e)) } ``` **Requesting Permissions:** ```rust use crate::audio::devices::discovery::trigger_audio_permission; #[tauri::command] fn request_mic_permission() -> Result { trigger_audio_permission() .map_err(|e| format!("Permission check error: {}", e)) } ``` These commands bridge the Rust audio subsystem with the JavaScript frontend, enabling real-time device lists and permission status updates in the user interface. ## Summary - **Centralized Discovery**: All audio device enumeration logic resides in [`frontend/src-tauri/src/audio/devices/discovery.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/discovery.rs), using CPAL's `default_host()` for cross-platform abstraction. - **Platform Specialization**: OS-specific configuration in `audio/devices/platform/` handles Windows WASAPI, Linux ALSA/PulseAudio, and macOS CoreAudio nuances. - **Complete Enumeration**: The system combines platform-preferred devices with a fallback scan of `host.devices()` to ensure no hardware is omitted. - **Typed Classifications**: Devices are represented as `AudioDevice` structs with `DeviceType` variants (`Input`, `Output`, `System`) defined in [`configuration.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/configuration.rs). - **Permission Management**: `trigger_audio_permission()` validates microphone access by constructing a temporary input stream on macOS and Windows. ## Frequently Asked Questions ### What library does Meetily use for audio device discovery? Meetily uses **CPAL** (Cross-Platform Audio Library), a Rust crate that provides uniform access to the native audio APIs of Windows (WASAPI), Linux (ALSA/PulseAudio), and macOS (CoreAudio). The library handles the low-level host abstraction while Meetily implements the high-level enumeration and classification logic. ### How does Meetily handle platform-specific audio differences? Platform-specific logic is isolated in separate modules under `frontend/src-tauri/src/audio/devices/platform/`. Each operating system has its own configuration function—`configure_windows_audio`, `configure_linux_audio`, and `configure_macos_audio`—that understands local conventions for default devices and system audio capture. ### Why is the device discovery function asynchronous? The **`list_audio_devices`** function is declared as `pub async fn` because certain platform callbacks within CPAL may operate asynchronously, particularly on macOS where device property queries can yield. However, the core enumeration logic executes synchronously once the host object is instantiated. ### How does Meetily check for microphone permissions? On macOS and Windows, Meetily calls **`trigger_audio_permission()`**, which attempts to build and play a minimal input stream using the default input device. If the stream starts successfully, permissions are granted; if the OS blocks access, the function returns an error that triggers the permission dialog for the user.