A free, open source, and extensible speech-to-text application that works completely offline.
Add a cancel hotkey and configuration (#224)
Jackson381b8a8bfb8e
diff --git a/src-tauri/src/actions.rs b/src-tauri/src/actions.rsindex 26b96334..f8d490f8 100644--- a/src-tauri/src/actions.rs+++ b/src-tauri/src/actions.rs@@ -2,10 +2,10 @@ use crate::audio_feedback::{play_feedback_sound, play_feedback_sound_blocking, Suse crate::managers::audio::AudioRecordingManager;use crate::managers::history::HistoryManager;use crate::managers::transcription::TranscriptionManager;-use crate::overlay::{show_recording_overlay, show_transcribing_overlay};use crate::settings::{get_settings, AppSettings};+use crate::shortcut;use crate::tray::{change_tray_icon, TrayIconState};-use crate::utils;+use crate::utils::{self, show_recording_overlay, show_transcribing_overlay};use async_openai::types::{ChatCompletionRequestMessage, ChatCompletionRequestUserMessageArgs,CreateChatCompletionRequestArgs,@@ -225,6 +225,7 @@ impl ShortcutAction for TranscribeAction {let is_always_on = settings.always_on_microphone;debug!("Microphone mode - always_on: {}", is_always_on);+ let mut recording_started = false;if is_always_on {// Always-on mode: Play audio feedback immediately, then apply mute after sound finishesdebug!("Always-on mode: Playing audio feedback immediately");@@ -237,7 +238,7 @@ impl ShortcutAction for TranscribeAction {rm_clone.apply_mute();});- let recording_started = rm.try_start_recording(&binding_id);+ recording_started = rm.try_start_recording(&binding_id);debug!("Recording started: {}", recording_started);} else {// On-demand mode: Start recording first, then play audio feedback, then apply mute@@ -245,6 +246,7 @@ impl ShortcutAction for TranscribeAction {debug!("On-demand mode: Starting recording first, then audio feedback");let recording_start_time = Instant::now();if rm.try_start_recording(&binding_id) {+ recording_started = true;debug!("Recording started in {:?}", recording_start_time.elapsed());// Small delay to ensure microphone stream is activelet app_clone = app.clone();@@ -262,6 +264,11 @@ impl ShortcutAction for TranscribeAction {}}+ if recording_started {+ // Dynamically register the cancel shortcut in a separate task to avoid deadlock+ shortcut::register_cancel_shortcut(app);+ }+debug!("TranscribeAction::start completed in {:?}",start_time.elapsed()@@ -269,6 +276,9 @@ impl ShortcutAction for TranscribeAction {}fn stop(&self, app: &AppHandle, binding_id: &str, _shortcut_str: &str) {+ // Unregister the cancel shortcut when transcription stops+ shortcut::unregister_cancel_shortcut(app);+let stop_time = Instant::now();debug!("TranscribeAction::stop called for binding: {}", binding_id);@@ -406,6 +416,19 @@ impl ShortcutAction for TranscribeAction {}}+// Cancel Action+struct CancelAction;++impl ShortcutAction for CancelAction {+ fn start(&self, app: &AppHandle, _binding_id: &str, _shortcut_str: &str) {+ utils::cancel_current_operation(app);+ }++ fn stop(&self, _app: &AppHandle, _binding_id: &str, _shortcut_str: &str) {+ // Nothing to do on stop for cancel+ }+}+// Test Actionstruct TestAction;@@ -436,6 +459,10 @@ pub static ACTION_MAP: Lazy<HashMap<String, Arc<dyn ShortcutAction>>> = Lazy::ne"transcribe".to_string(),Arc::new(TranscribeAction) as Arc<dyn ShortcutAction>,);+ map.insert(+ "cancel".to_string(),+ Arc::new(CancelAction) as Arc<dyn ShortcutAction>,+ );map.insert("test".to_string(),Arc::new(TestAction) as Arc<dyn ShortcutAction>,diff --git a/src-tauri/src/managers/audio.rs b/src-tauri/src/managers/audio.rsindex 8d86e613..0add01fc 100644--- a/src-tauri/src/managers/audio.rs+++ b/src-tauri/src/managers/audio.rs@@ -414,6 +414,12 @@ impl AudioRecordingManager {_ => None,}}+ pub fn is_recording(&self) -> bool {+ matches!(+ *self.state.lock().unwrap(),+ RecordingState::Recording { .. }+ )+ }/// Cancel any ongoing recording without returning audio samplespub fn cancel_recording(&self) {diff --git a/src-tauri/src/settings.rs b/src-tauri/src/settings.rsindex d5db7049..0c3a0ba6 100644--- a/src-tauri/src/settings.rs+++ b/src-tauri/src/settings.rs@@ -432,6 +432,16 @@ pub fn get_default_settings() -> AppSettings {current_binding: default_shortcut.to_string(),},);+ bindings.insert(+ "cancel".to_string(),+ ShortcutBinding {+ id: "cancel".to_string(),+ name: "Cancel".to_string(),+ description: "Cancels the current recording.".to_string(),+ default_binding: "escape".to_string(),+ current_binding: "escape".to_string(),+ },+ );AppSettings {bindings,@@ -501,8 +511,25 @@ pub fn load_or_create_app_settings(app: &AppHandle) -> AppSettings {let settings = if let Some(settings_value) = store.get("settings") {// Parse the entire settings objectmatch serde_json::from_value::<AppSettings>(settings_value) {- Ok(settings) => {+ Ok(mut settings) => {debug!("Found existing settings: {:?}", settings);+ let default_settings = get_default_settings();+ let mut updated = false;++ // Merge default bindings into existing settings+ for (key, value) in default_settings.bindings {+ if !settings.bindings.contains_key(&key) {+ debug!("Adding missing binding: {}", key);+ settings.bindings.insert(key, value);+ updated = true;+ }+ }++ if updated {+ debug!("Settings updated with new bindings");+ store.set("settings", serde_json::to_value(&settings).unwrap());+ }+settings}Err(e) => {diff --git a/src-tauri/src/shortcut.rs b/src-tauri/src/shortcut.rsindex e070e446..edfdb5c6 100644--- a/src-tauri/src/shortcut.rs+++ b/src-tauri/src/shortcut.rs@@ -1,11 +1,13 @@use log::{error, warn};use serde::Serialize;use specta::Type;+use std::sync::Arc;use tauri::{AppHandle, Emitter, Manager};use tauri_plugin_autostart::ManagerExt;use tauri_plugin_global_shortcut::{GlobalShortcutExt, Shortcut, ShortcutState};use crate::actions::ACTION_MAP;+use crate::managers::audio::AudioRecordingManager;use crate::settings::ShortcutBinding;use crate::settings::{self, get_settings, ClipboardHandling, LLMPrompt, OverlayPosition, PasteMethod, SoundTheme,@@ -13,12 +15,23 @@ use crate::settings::{use crate::ManagedToggleState;pub fn init_shortcuts(app: &AppHandle) {- let settings = settings::load_or_create_app_settings(app);+ let default_bindings = settings::get_default_settings().bindings;+ let user_settings = settings::load_or_create_app_settings(app);- // Register shortcuts with the bindings from settings- for (_id, binding) in settings.bindings {- if let Err(e) = _register_shortcut(app, binding) {- error!("Failed to register shortcut {} during init: {}", _id, e);++ // Register all default shortcuts, applying user customizations+ for (id, default_binding) in default_bindings {+ if id == "cancel" {+ continue; // Skip cancel shortcut, it will be registered dynamically+ }+ let binding = user_settings+ .bindings+ .get(&id)+ .cloned()+ .unwrap_or(default_binding);++ if let Err(e) = register_shortcut(app, binding) {+ error!("Failed to register shortcut {} during init: {}", id, e);}}}@@ -52,9 +65,23 @@ pub fn change_binding(});}};+ // If this is the cancel binding, just update the settings and return+ // It's managed dynamically, so we don't register/unregister here+ if id == "cancel" {+ if let Some(mut b) = settings.bindings.get(&id).cloned() {+ b.current_binding = binding;+ settings.bindings.insert(id.clone(), b.clone());+ settings::write_settings(&app, settings);+ return Ok(BindingResponse {+ success: true,+ binding: Some(b.clone()),+ error: None,+ });+ }+ }// Unregister the existing binding- if let Err(e) = _unregister_shortcut(&app, binding_to_modify.clone()) {+ if let Err(e) = unregister_shortcut(&app, binding_to_modify.clone()) {let error_msg = format!("Failed to unregister shortcut: {}", e);error!("change_binding error: {}", error_msg);}@@ -70,7 +97,7 @@ pub fn change_binding(updated_binding.current_binding = binding;// Register the new binding- if let Err(e) = _register_shortcut(&app, updated_binding.clone()) {+ if let Err(e) = register_shortcut(&app, updated_binding.clone()) {let error_msg = format!("Failed to register shortcut: {}", e);error!("change_binding error: {}", error_msg);return Ok(BindingResponse {@@ -673,7 +700,7 @@ fn validate_shortcut_string(raw: &str) -> Result<(), String> {#[specta::specta]pub fn suspend_binding(app: AppHandle, id: String) -> Result<(), String> {if let Some(b) = settings::get_bindings(&app).get(&id).cloned() {- if let Err(e) = _unregister_shortcut(&app, b) {+ if let Err(e) = unregister_shortcut(&app, b) {error!("suspend_binding error for id '{}': {}", id, e);return Err(e);}@@ -686,7 +713,7 @@ pub fn suspend_binding(app: AppHandle, id: String) -> Result<(), String> {#[specta::specta]pub fn resume_binding(app: AppHandle, id: String) -> Result<(), String> {if let Some(b) = settings::get_bindings(&app).get(&id).cloned() {- if let Err(e) = _register_shortcut(&app, b) {+ if let Err(e) = register_shortcut(&app, b) {error!("resume_binding error for id '{}': {}", id, e);return Err(e);}@@ -694,7 +721,28 @@ pub fn resume_binding(app: AppHandle, id: String) -> Result<(), String> {Ok(())}-fn _register_shortcut(app: &AppHandle, binding: ShortcutBinding) -> Result<(), String> {+pub fn register_cancel_shortcut(app: &AppHandle) {+ let app_clone = app.clone();+ tauri::async_runtime::spawn(async move {+ if let Some(cancel_binding) = get_settings(&app_clone).bindings.get("cancel").cloned() {+ if let Err(e) = register_shortcut(&app_clone, cancel_binding) {+ eprintln!("Failed to register cancel shortcut: {}", e);+ }+ }+ });+}++pub fn unregister_cancel_shortcut(app: &AppHandle) {+ let app_clone = app.clone();+ tauri::async_runtime::spawn(async move {+ if let Some(cancel_binding) = get_settings(&app_clone).bindings.get("cancel").cloned() {+ // We ignore errors here as it might already be unregistered+ let _ = unregister_shortcut(&app_clone, cancel_binding);+ }+ });+}++pub fn register_shortcut(app: &AppHandle, binding: ShortcutBinding) -> Result<(), String> {// Validate human-level rules firstif let Err(e) = validate_shortcut_string(&binding.current_binding) {warn!(@@ -734,7 +782,13 @@ fn _register_shortcut(app: &AppHandle, binding: ShortcutBinding) -> Result<(), Slet settings = get_settings(ah);if let Some(action) = ACTION_MAP.get(&binding_id_for_closure) {- if settings.push_to_talk {+ if binding_id_for_closure == "cancel" {+ let audio_manager = ah.state::<Arc<AudioRecordingManager>>();+ if audio_manager.is_recording() && event.state == ShortcutState::Pressed {+ action.start(ah, &binding_id_for_closure, &shortcut_string);+ }+ return;+ } else if settings.push_to_talk {if event.state == ShortcutState::Pressed {action.start(ah, &binding_id_for_closure, &shortcut_string);} else if event.state == ShortcutState::Released {@@ -780,7 +834,7 @@ fn _register_shortcut(app: &AppHandle, binding: ShortcutBinding) -> Result<(), SOk(())}-fn _unregister_shortcut(app: &AppHandle, binding: ShortcutBinding) -> Result<(), String> {+pub fn unregister_shortcut(app: &AppHandle, binding: ShortcutBinding) -> Result<(), String> {let shortcut = match binding.current_binding.parse::<Shortcut>() {Ok(s) => s,Err(e) => {diff --git a/src-tauri/src/utils.rs b/src-tauri/src/utils.rsindex 7a77d3b5..636ef8ef 100644--- a/src-tauri/src/utils.rs+++ b/src-tauri/src/utils.rs@@ -1,5 +1,5 @@-use crate::actions::ACTION_MAP;use crate::managers::audio::AudioRecordingManager;+use crate::shortcut;use crate::ManagedToggleState;use log::{info, warn};use std::sync::Arc;@@ -16,31 +16,14 @@ pub use crate::tray::*;pub fn cancel_current_operation(app: &AppHandle) {info!("Initiating operation cancellation...");- // First, reset all shortcut toggle states and call stop actions+ // Unregister the cancel shortcut asynchronously+ shortcut::unregister_cancel_shortcut(app);++ // First, reset all shortcut toggle states.// This is critical for non-push-to-talk mode where shortcuts toggle on/offlet toggle_state_manager = app.state::<ManagedToggleState>();if let Ok(mut states) = toggle_state_manager.lock() {- // For each currently active toggle, call its stop action and reset state- let active_bindings: Vec<String> = states- .active_toggles- .iter()- .filter(|(_, &is_active)| is_active)- .map(|(binding_id, _)| binding_id.clone())- .collect();-- for binding_id in active_bindings {- info!("Stopping active action for binding: {}", binding_id);-- // Call the action's stop method to ensure proper cleanup- if let Some(action) = ACTION_MAP.get(&binding_id) {- action.stop(app, &binding_id, "cancelled");- }-- // Reset the toggle state- if let Some(is_active) = states.active_toggles.get_mut(&binding_id) {- *is_active = false;- }- }+ states.active_toggles.values_mut().for_each(|v| *v = false);} else {warn!("Failed to lock toggle state manager during cancellation");}@@ -49,8 +32,9 @@ pub fn cancel_current_operation(app: &AppHandle) {let audio_manager = app.state::<Arc<AudioRecordingManager>>();audio_manager.cancel_recording();- // Update tray icon and menu to idle state+ // Update tray icon and hide overlaychange_tray_icon(app, crate::tray::TrayIconState::Idle);+ hide_recording_overlay(app);info!("Operation cancellation completed - returned to idle state");}diff --git a/src/components/settings/HandyShortcut.tsx b/src/components/settings/HandyShortcut.tsxindex 8b64e714..eb27a6d7 100644--- a/src/components/settings/HandyShortcut.tsx+++ b/src/components/settings/HandyShortcut.tsx@@ -15,11 +15,15 @@ import { toast } from "sonner";interface HandyShortcutProps {descriptionMode?: "inline" | "tooltip";grouped?: boolean;+ shortcutId: string;+ disabled?: boolean;}export const HandyShortcut: React.FC<HandyShortcutProps> = ({descriptionMode = "tooltip",grouped = false,+ shortcutId,+ disabled = false,}) => {const { getSetting, updateBinding, resetBinding, isUpdating, isLoading } =useSettings();@@ -267,48 +271,50 @@ export const HandyShortcut: React.FC<HandyShortcutProps> = ({);}+ const binding = bindings[shortcutId];+ if (!binding) {+ return (+ <SettingContainer+ title="Shortcut"+ description="Shortcut not found"+ descriptionMode={descriptionMode}+ grouped={grouped}+ >+ <div className="text-sm text-mid-gray">No shortcut configured</div>+ </SettingContainer>+ );+ }+return (<SettingContainer- title="Handy Shortcut"- description="Set the keyboard shortcut to start and stop speech-to-text recording"+ title={binding.name}+ description={binding.description}descriptionMode={descriptionMode}grouped={grouped}- tooltipPosition="bottom"+ disabled={disabled}+ layout="horizontal">- {(() => {- const primaryBinding = Object.values(bindings)[0];- const primaryId = Object.keys(bindings)[0];-- if (!primaryBinding) {- return (- <div className="text-sm text-mid-gray">No shortcuts configured</div>- );- }-- return (- <div className="flex items-center space-x-1">- {editingShortcutId === primaryId ? (- <div- ref={(ref) => setShortcutRef(primaryId, ref)}- className="px-2 py-1 text-sm font-semibold border border-logo-primary bg-logo-primary/30 rounded min-w-[120px] text-center"- >- {formatCurrentKeys()}- </div>- ) : (- <div- className="px-2 py-1 text-sm font-semibold bg-mid-gray/10 border border-mid-gray/80 hover:bg-logo-primary/10 rounded cursor-pointer hover:border-logo-primary"- onClick={() => startRecording(primaryId)}- >- {formatKeyCombination(primaryBinding.current_binding, osType)}- </div>- )}- <ResetButton- onClick={() => resetBinding(primaryId)}- disabled={isUpdating(`binding_${primaryId}`)}- />+ <div className="flex items-center space-x-1">+ {editingShortcutId === shortcutId ? (+ <div+ ref={(ref) => setShortcutRef(shortcutId, ref)}+ className="px-2 py-1 text-sm font-semibold border border-logo-primary bg-logo-primary/30 rounded min-w-[120px] text-center"+ >+ {formatCurrentKeys()}+ </div>+ ) : (+ <div+ className="px-2 py-1 text-sm font-semibold bg-mid-gray/10 border border-mid-gray/80 hover:bg-logo-primary/10 rounded cursor-pointer hover:border-logo-primary"+ onClick={() => startRecording(shortcutId)}+ >+ {formatKeyCombination(binding.current_binding, osType)}</div>- );- })()}+ )}+ <ResetButton+ onClick={() => resetBinding(shortcutId)}+ disabled={isUpdating(`binding_${shortcutId}`)}+ />+ </div></SettingContainer>);};diff --git a/src/components/settings/debug/DebugSettings.tsx b/src/components/settings/debug/DebugSettings.tsxindex 35f20b97..dbc9a9ae 100644--- a/src/components/settings/debug/DebugSettings.tsx+++ b/src/components/settings/debug/DebugSettings.tsx@@ -10,8 +10,13 @@ import { PostProcessingToggle } from "../PostProcessingToggle";import { MuteWhileRecording } from "../MuteWhileRecording";import { RecordingRetentionPeriodSelector } from "../RecordingRetentionPeriod";import { ClamshellMicrophoneSelector } from "../ClamshellMicrophoneSelector";+import { HandyShortcut } from "../HandyShortcut";+import { useSettings } from "../../../hooks/useSettings";export const DebugSettings: React.FC = () => {+ const { getSetting } = useSettings();+ const pushToTalk = getSetting("push_to_talk");+return (<div className="max-w-3xl w-full mx-auto space-y-6"><SettingsGroup title="Debug">@@ -31,6 +36,11 @@ export const DebugSettings: React.FC = () => {<ClamshellMicrophoneSelector descriptionMode="tooltip" grouped={true} /><PostProcessingToggle descriptionMode="tooltip" grouped={true} /><MuteWhileRecording descriptionMode="tooltip" grouped={true} />+ <HandyShortcut+ shortcutId="cancel"+ grouped={true}+ disabled={pushToTalk}+ /></SettingsGroup></div>);diff --git a/src/components/settings/general/GeneralSettings.tsx b/src/components/settings/general/GeneralSettings.tsxindex fe148583..57bd9ec0 100644--- a/src/components/settings/general/GeneralSettings.tsx+++ b/src/components/settings/general/GeneralSettings.tsx@@ -14,7 +14,7 @@ export const GeneralSettings: React.FC = () => {return (<div className="max-w-3xl w-full mx-auto space-y-6"><SettingsGroup title="General">- <HandyShortcut descriptionMode="tooltip" grouped={true} />+ <HandyShortcut shortcutId="transcribe" grouped={true} /><LanguageSelector descriptionMode="tooltip" grouped={true} /><PushToTalk descriptionMode="tooltip" grouped={true} /></SettingsGroup>