feat: add microphone selection with bidirectional sync

- Add microphone selection in both settings UI and system tray
- Implement bidirectional sync between dashboard and menubar
- Auto-fallback to default when selected device unavailable
- Stop recording automatically when microphone changes
- Replace license restore with Polar customer portal link
- Change email links to copy-to-clipboard functionality
- Remove unused components (license folder, example files)

Author: moinulmoin

src-tauri/src/audio/recorder.rs

@@ -74,7 +74,7 @@ impl AudioRecorder {
         }
     }
 
-    pub fn start_recording(&mut self, output_path: &str) -> Result<(), String> {
+    pub fn start_recording(&mut self, output_path: &str, device_name: Option<String>) -> Result<(), String> {
         log::info!(
             "AudioRecorder::start_recording called with path: {}",
             output_path
@@ -109,9 +109,25 @@ impl AudioRecorder {
         // Spawn recording thread
         let thread_handle = thread::spawn(move || -> Result<String, String> {
             let host = cpal::default_host();
-            let device = host
-                .default_input_device()
-                .ok_or("No input device available")?;
+            let device = if let Some(device_name) = device_name {
+                // Try to find the specified device
+                host.input_devices()
+                    .map_err(|e| format!("Failed to enumerate input devices: {}", e))?
+                    .find(|d| d.name().map(|n| n == device_name).unwrap_or(false))
+                    .ok_or_else(|| {
+                        log::warn!("Specified device '{}' not found, falling back to default", device_name);
+                        format!("Device '{}' not found", device_name)
+                    })
+                    .or_else(|_| {
+                        // Fallback to default device if specified device not found
+                        host.default_input_device()
+                            .ok_or("No input device available".to_string())
+                    })?
+            } else {
+                // Use default device
+                host.default_input_device()
+                    .ok_or("No input device available")?
+            };
 
             let device_name = device.name().unwrap_or_else(|_| "Unknown".to_string());
             log::info!("======================================");

src-tauri/src/commands/audio.rs

@@ -3,6 +3,7 @@ use tauri::{AppHandle, Manager, State};
 use crate::audio::recorder::AudioRecorder;
 use crate::audio::validator::{AudioValidator, AudioValidationResult};
 use crate::commands::license::check_license_status_internal;
+use crate::commands::settings::get_settings;
 use crate::license::LicenseState;
 use crate::utils::logger::*;
 #[cfg(debug_assertions)]
@@ -175,6 +176,23 @@ pub async fn start_recording(
         .map_err(|e| format!("Failed to acquire path lock: {}", e))?
         .replace(audio_path.clone());
 
+    // Get selected microphone from settings (before acquiring recorder lock)
+    let selected_microphone = match get_settings(app.clone()).await {
+        Ok(settings) => {
+            if let Some(mic) = settings.selected_microphone {
+                log::info!("Using selected microphone: {}", mic);
+                Some(mic)
+            } else {
+                log::info!("Using default microphone");
+                None
+            }
+        },
+        Err(e) => {
+            log::warn!("Failed to get settings for microphone selection: {}. Using default.", e);
+            None
+        }
+    };
+
     // Start recording (scoped to release mutex before async operations)
     {
         let mut recorder = state
@@ -226,10 +244,17 @@ pub async fn start_recording(
 
         log_file_operation("RECORDING_START", audio_path_str, false, None, None);
 
-        match recorder.start_recording(audio_path_str) {
+        // Start recording and get audio level receiver
+        let audio_level_rx = match recorder.start_recording(audio_path_str, selected_microphone.clone()) {
             Ok(_) => {
                 // Verify recording actually started
-                if !recorder.is_recording() {
+                let is_recording = recorder.is_recording();
+                
+                // Get the audio level receiver before potentially dropping recorder
+                let rx = recorder.take_audio_level_receiver();
+                
+                if !is_recording {
+                    drop(recorder); // Release the lock if we're erroring out
                     log_failed("RECORDER_INIT", "Recording failed to start after initialization");
                     log_with_context(log::Level::Debug, "Recorder initialization failed", &[
                         ("audio_path", audio_path_str),
@@ -257,6 +282,8 @@ pub async fn start_recording(
                     #[cfg(debug_assertions)]
                     system_monitor::log_resources_before_operation("RECORDING_START");
                 }
+                
+                rx // Return the audio level receiver
             }
             Err(e) => {
                 log_failed("RECORDER_START", &e);
@@ -282,10 +309,13 @@ pub async fn start_recording(
 
                 return Err(e);
             }
-        }
+        };
+
+        // Release the recorder lock after successful start
+        drop(recorder);
 
-        // Start audio level monitoring before releasing the lock
-        if let Some(audio_level_rx) = recorder.take_audio_level_receiver() {
+        // Start audio level monitoring 
+        if let Some(audio_level_rx) = audio_level_rx {
             let app_for_levels = app.clone();
             // Use a thread instead of tokio spawn for std::sync::mpsc
             std::thread::spawn(move || {
@@ -592,7 +622,7 @@ pub async fn stop_recording(
 
             return Ok("".to_string()); // Don't proceed to transcription
         }
-        Ok(AudioValidationResult::TooQuiet { energy, suggestion }) => {
+        Ok(AudioValidationResult::TooQuiet { energy, suggestion: _ }) => {
             log::warn!("Audio validation FAILED: Audio too quiet (RMS={:.6})", energy);
 
             // Clean up audio file

src-tauri/src/commands/settings.rs

@@ -20,6 +20,7 @@ pub struct Settings {
     pub onboarding_completed: bool,
     pub compact_recording_status: bool,
     pub check_updates_automatically: bool,
+    pub selected_microphone: Option<String>,
 }
 
 impl Default for Settings {
@@ -36,6 +37,7 @@ impl Default for Settings {
             onboarding_completed: false,      // Default to not completed
             compact_recording_status: true,   // Default to compact mode
             check_updates_automatically: true, // Default to automatic updates enabled
+            selected_microphone: None,        // Default to system default microphone
         }
     }
 }
@@ -97,6 +99,9 @@ pub async fn get_settings(app: AppHandle) -> Result<Settings, String> {
             .get("check_updates_automatically")
             .and_then(|v| v.as_bool())
             .unwrap_or_else(|| Settings::default().check_updates_automatically),
+        selected_microphone: store
+            .get("selected_microphone")
+            .and_then(|v| v.as_str().map(|s| s.to_string())),
     };
 
     // Pill position is already loaded from store, no need for duplicate state
@@ -137,6 +142,7 @@ pub async fn save_settings(app: AppHandle, settings: Settings) -> Result<(), Str
         "check_updates_automatically",
         json!(settings.check_updates_automatically),
     );
+    store.set("selected_microphone", json!(settings.selected_microphone));
 
     // Save pill position if provided
     if let Some((x, y)) = settings.pill_position {
@@ -329,3 +335,56 @@ pub async fn update_tray_menu(app: AppHandle) -> Result<(), String> {
 
     Ok(())
 }
+
+/// Set the selected microphone device
+#[tauri::command]
+pub async fn set_audio_device(app: AppHandle, device_name: Option<String>) -> Result<(), String> {
+    log::info!("Setting audio device to: {:?}", device_name);
+    
+    // Get current settings
+    let mut settings = get_settings(app.clone()).await?;
+    
+    // Check if recording is in progress and stop it
+    let recorder_state = app.state::<crate::commands::audio::RecorderState>();
+    {
+        let mut recorder = recorder_state.inner().0.lock()
+            .map_err(|e| format!("Failed to acquire recorder lock: {}", e))?;
+        
+        if recorder.is_recording() {
+            log::info!("Recording in progress, stopping it before changing microphone");
+            
+            // Update state to notify UI
+            crate::update_recording_state(&app, crate::RecordingState::Stopping, None);
+            
+            match recorder.stop_recording() {
+                Ok(msg) => {
+                    log::info!("Recording stopped: {}", msg);
+                    // Update state to idle after successful stop
+                    crate::update_recording_state(&app, crate::RecordingState::Idle, None);
+                },
+                Err(e) => {
+                    log::warn!("Failed to stop recording: {}", e);
+                    // Update state to error if stop failed
+                    crate::update_recording_state(&app, crate::RecordingState::Error, Some(e));
+                }
+            }
+        }
+    } // Lock released here
+    
+    // Update the selected microphone
+    settings.selected_microphone = device_name.clone();
+    
+    // Save the updated settings
+    save_settings(app.clone(), settings).await?;
+    
+    // Update tray menu to reflect the change
+    update_tray_menu(app.clone()).await?;
+    
+    // Emit event to notify frontend - just emit a signal, frontend will reload settings
+    if let Err(e) = app.emit("audio-device-changed", ()) {
+        log::warn!("Failed to emit audio-device-changed event: {}", e);
+    }
+    
+    log::info!("Audio device successfully set to: {:?}", device_name);
+    Ok(())
+}

src-tauri/src/lib.rs

@@ -64,13 +64,19 @@ async fn build_tray_menu<R: tauri::Runtime>(
     app: &tauri::AppHandle<R>,
 ) -> Result<tauri::menu::Menu<R>, Box<dyn std::error::Error>> {
     // Get current settings for menu state
-    let current_model = {
+    let (current_model, selected_microphone) = {
         match app.store("settings") {
-            Ok(store) => store
-                .get("current_model")
-                .and_then(|v| v.as_str().map(|s| s.to_string()))
-                .unwrap_or_default(),
-            Err(_) => "".to_string(),
+            Ok(store) => {
+                let model = store
+                    .get("current_model")
+                    .and_then(|v| v.as_str().map(|s| s.to_string()))
+                    .unwrap_or_default();
+                let microphone = store
+                    .get("selected_microphone")
+                    .and_then(|v| v.as_str().map(|s| s.to_string()));
+                (model, microphone)
+            }
+            Err(_) => ("".to_string(), None),
         }
     };
 
@@ -131,6 +137,61 @@ async fn build_tray_menu<R: tauri::Runtime>(
         None
     };
 
+    // Get available audio devices
+    let available_devices = audio::recorder::AudioRecorder::get_devices();
+    
+    // Create microphone submenu
+    let microphone_submenu = if !available_devices.is_empty() {
+        let mut mic_items: Vec<&dyn tauri::menu::IsMenuItem<_>> = Vec::new();
+        let mut mic_check_items = Vec::new();
+
+        // Add "Default" option first
+        let default_item = CheckMenuItem::with_id(
+            app,
+            "microphone_default",
+            "System Default",
+            true,
+            selected_microphone.is_none(), // Selected if no specific microphone is set
+            None::<&str>,
+        )?;
+        mic_check_items.push(default_item);
+
+        // Add available devices
+        for device_name in &available_devices {
+            let is_selected = selected_microphone.as_ref() == Some(device_name);
+            let mic_item = CheckMenuItem::with_id(
+                app,
+                &format!("microphone_{}", device_name),
+                device_name,
+                true,
+                is_selected,
+                None::<&str>,
+            )?;
+            mic_check_items.push(mic_item);
+        }
+
+        // Convert to trait objects
+        for item in &mic_check_items {
+            mic_items.push(item);
+        }
+
+        let current_mic_display = if let Some(ref mic_name) = selected_microphone {
+            format!("Microphone: {}", mic_name)
+        } else {
+            "Microphone: Default".to_string()
+        };
+
+        Some(Submenu::with_id_and_items(
+            app,
+            "microphones",
+            &current_mic_display,
+            true,
+            &mic_items,
+        )?)
+    } else {
+        None
+    };
+
     // Create menu items
     let separator1 = PredefinedMenuItem::separator(app)?;
     let settings_i = MenuItem::with_id(app, "settings", "Dashboard", true, None::<&str>)?;
@@ -142,6 +203,10 @@ async fn build_tray_menu<R: tauri::Runtime>(
     if let Some(model_submenu) = model_submenu {
         menu_builder = menu_builder.item(&model_submenu);
     }
+    
+    if let Some(microphone_submenu) = microphone_submenu {
+        menu_builder = menu_builder.item(&microphone_submenu);
+    }
 
     let menu = menu_builder
         .item(&separator1)
@@ -861,6 +926,43 @@ pub fn run() -> Result<(), Box<dyn std::error::Error>> {
                                 }
                             }
                         });
+                    } else if event_id == "microphone_default" {
+                        // Handle default microphone selection
+                        let app_handle = app.app_handle().clone();
+                        
+                        tauri::async_runtime::spawn(async move {
+                            match crate::commands::settings::set_audio_device(app_handle.clone(), None).await {
+                                Ok(_) => {
+                                    log::info!("Microphone changed from tray to: System Default");
+                                }
+                                Err(e) => {
+                                    log::error!("Failed to set default microphone from tray: {}", e);
+                                    let _ = app_handle.emit("tray-action-error", &format!("Failed to change microphone: {}", e));
+                                }
+                            }
+                        });
+                    } else if event_id.starts_with("microphone_") {
+                        // Handle specific microphone selection
+                        let device_name = match event_id.strip_prefix("microphone_") {
+                            Some(name) if name != "default" => Some(name.to_string()),
+                            _ => {
+                                // Already handled by microphone_default case above
+                                return;
+                            }
+                        };
+                        let app_handle = app.app_handle().clone();
+
+                        tauri::async_runtime::spawn(async move {
+                            match crate::commands::settings::set_audio_device(app_handle.clone(), device_name.clone()).await {
+                                Ok(_) => {
+                                    log::info!("Microphone changed from tray to: {:?}", device_name);
+                                }
+                                Err(e) => {
+                                    log::error!("Failed to set microphone from tray: {}", e);
+                                    let _ = app_handle.emit("tray-action-error", &format!("Failed to change microphone: {}", e));
+                                }
+                            }
+                        });
                     }
                 })
                 .on_tray_icon_event(|tray, event| {
@@ -1151,6 +1253,7 @@ pub fn run() -> Result<(), Box<dyn std::error::Error>> {
             transcribe_audio,
             get_settings,
             save_settings,
+            set_audio_device,
             set_global_shortcut,
             get_supported_languages,
             set_model_from_tray,