A free, open source, and extensible speech-to-text application that works completely offline.
remove keybinding manager
CJ Pais97700cda60e5
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rsindex 3e8b51c1..ec51c680 100644--- a/src-tauri/src/lib.rs+++ b/src-tauri/src/lib.rs@@ -2,7 +2,6 @@ mod managers;use log::info;use managers::audio::AudioRecordingManager;-use managers::keybinding::KeyBindingManager;use managers::transcription::TranscriptionManager;use rdev::{simulate, EventType, Key, SimulateError};use std::sync::{Arc, Mutex};@@ -51,33 +50,6 @@ fn paste(text: String, app_handle: tauri::AppHandle) {clipboard.write_text(&clipboard_content).unwrap();}-fn register_bindings(manager: &mut KeyBindingManager) {- manager.register(- "ctrl-meta".to_string(),- vec![Key::ControlRight, Key::MetaRight],- |ctx| {- info!("Ctrl+Meta pressed!");- ctx.recording_manager.try_start_recording("ctrl-meta");- None- },- |ctx| {- info!("release being called from ctrl-meta");- let ctx = ctx.clone();- Some(tauri::async_runtime::spawn(async move {- if let Some(samples) = ctx.recording_manager.stop_recording("ctrl-meta") {- match ctx.transcription_manager.transcribe(samples) {- Ok(transcription) => {- println!("Transcription: {}", transcription);- paste(transcription, ctx.app_handle.clone());- }- Err(err) => println!("Transcription error: {}", err),- }- }- }))- },- );-}-#[cfg_attr(mobile, tauri::mobile_entry_point)]pub fn run() {env_logger::init();@@ -94,8 +66,6 @@ pub fn run() {.plugin(tauri_plugin_macos_permissions::init()).plugin(tauri_plugin_opener::init()).setup(move |app| {- let app_handle = app.handle().clone();-let vad_path = app.path().resolve("resources/silero_vad_v4.onnx",tauri::path::BaseDirectory::Resource,@@ -119,54 +89,54 @@ pub fn run() {.expect("Failed to initialize transcription manager"),);- let manager = Arc::new(Mutex::new(KeyBindingManager::new(- recording_manager.clone(),- transcription_manager.clone(),- // claude_client.clone(),- app_handle.clone(),- )));-- {- let mut manager = manager.lock().unwrap();- register_bindings(&mut manager);- }-- let manager_clone = manager.clone();- tauri::async_runtime::spawn(async move {- rdev::listen(move |event| {- if let Ok(manager) = manager_clone.lock() {- manager.handle_event(&event);- }- })- .unwrap();- });-#[cfg(desktop)]{use tauri_plugin_global_shortcut::{Code, Modifiers, ShortcutState};+ // Clone resources needed for the global shortcut handler+ let rm_for_shortcut_handler = recording_manager.clone();+ let tm_for_shortcut_handler = transcription_manager.clone();+app.handle().plugin(tauri_plugin_global_shortcut::Builder::new()- .with_shortcuts(["ctrl+d", "alt+space"])?- .with_handler(|app, shortcut, event| {- if event.state == ShortcutState::Pressed {- if shortcut.matches(Modifiers::CONTROL, Code::KeyD) {- let _ = app.emit("shortcut-event", "Ctrl+D triggered");- println!("Ctrl+D triggered");- }- if shortcut.matches(Modifiers::ALT, Code::Space) {- let _ = app.emit("shortcut-event", "Alt+Space triggered");- println!("Alt+Space triggered");- }- }- if event.state == ShortcutState::Released {- if shortcut.matches(Modifiers::CONTROL, Code::KeyD) {- let _ = app.emit("shortcut-event", "Ctrl+D released");- println!("Ctrl+D released");- }- if shortcut.matches(Modifiers::ALT, Code::Space) {- let _ = app.emit("shortcut-event", "Alt+Space released");- println!("Alt+Space released");+ .with_shortcuts(["alt+space"])? // Register "alt+space"+ .with_handler(move |app_handle_from_plugin, shortcut, event| {+ // Clone Arcs for potential async tasks to move ownership+ let recording_manager = rm_for_shortcut_handler.clone();+ let transcription_manager = tm_for_shortcut_handler.clone();+ let app_handle_for_async_tasks = app_handle_from_plugin.clone();++ if shortcut.matches(Modifiers::ALT, Code::Space) {+ if event.state == ShortcutState::Pressed {+ info!("Alt+Space pressed! (Global Shortcut)");+ // Use the "alt-space" identifier for consistency+ recording_manager.try_start_recording("alt-space");+ } else if event.state == ShortcutState::Released {+ info!("Alt+Space released! (Global Shortcut)");+ tauri::async_runtime::spawn(async move {+ // recording_manager, transcription_manager, and app_handle_for_async_tasks are moved into this async block+ if let Some(samples) =+ recording_manager.stop_recording("alt-space")+ {+ match transcription_manager.transcribe(samples) {+ // Not .await, as transcribe is synchronous+ Ok(transcription) => {+ println!(+ "Global Shortcut Transcription: {}",+ transcription+ );+ paste(+ transcription,+ app_handle_for_async_tasks,+ );+ }+ Err(err) => println!(+ "Global Shortcut Transcription error: {}",+ err+ ),+ }+ }+ });}}})diff --git a/src-tauri/src/managers/keybinding.rs b/src-tauri/src/managers/keybinding.rsdeleted file mode 100644index c42cf8a7..00000000--- a/src-tauri/src/managers/keybinding.rs+++ /dev/null@@ -1,130 +0,0 @@-use super::audio::AudioRecordingManager;-use super::transcription::TranscriptionManager;-use rdev::{EventType, Key};-use std::collections::HashSet;-use std::sync::{Arc, Mutex};--type KeySet = HashSet<Key>;--#[derive(Clone)]-pub struct BindingContext {- pub recording_manager: Arc<AudioRecordingManager>,- pub transcription_manager: Arc<TranscriptionManager>,- // pub anthropic: Arc<anthropic::Client>,- pub app_handle: tauri::AppHandle,-}--pub struct KeyBinding {- id: String,- keys: KeySet,- on_press: Box<- dyn Fn(&BindingContext) -> Option<tauri::async_runtime::JoinHandle<()>> + Send + 'static,- >,- on_release: Box<- dyn Fn(&BindingContext) -> Option<tauri::async_runtime::JoinHandle<()>> + Send + 'static,- >,-}--impl KeyBinding {- fn new<F, G>(id: String, keys: Vec<Key>, on_press: F, on_release: G) -> Self- where- F: Fn(&BindingContext) -> Option<tauri::async_runtime::JoinHandle<()>> + Send + 'static,- G: Fn(&BindingContext) -> Option<tauri::async_runtime::JoinHandle<()>> + Send + 'static,- {- Self {- id,- keys: keys.into_iter().collect(),- on_press: Box::new(on_press),- on_release: Box::new(on_release),- }- }-}--pub struct KeyBindingManager {- bindings: Vec<KeyBinding>,- global_pressed: Arc<Mutex<HashSet<Key>>>,- active_bindings: Arc<Mutex<HashSet<String>>>,- context: BindingContext,-}--impl KeyBindingManager {- pub fn new(- recording_manager: Arc<AudioRecordingManager>,- transcription_manager: Arc<TranscriptionManager>,- // anthropic: Arc<anthropic::Client>,- app_handle: tauri::AppHandle,- ) -> Self {- Self {- bindings: Vec::new(),- global_pressed: Arc::new(Mutex::new(HashSet::new())),- active_bindings: Arc::new(Mutex::new(HashSet::new())),- context: BindingContext {- recording_manager,- transcription_manager,- // anthropic,- app_handle,- },- }- }-- pub fn register<F, G>(&mut self, id: String, keys: Vec<Key>, on_press: F, on_release: G)- where- F: Fn(&BindingContext) -> Option<tauri::async_runtime::JoinHandle<()>> + Send + 'static,- G: Fn(&BindingContext) -> Option<tauri::async_runtime::JoinHandle<()>> + Send + 'static,- {- self.bindings- .push(KeyBinding::new(id, keys, on_press, on_release));- }-- pub fn handle_event(&self, event: &rdev::Event) {- if let EventType::KeyPress(key) | EventType::KeyRelease(key) = event.event_type {- let mut is_press = matches!(event.event_type, EventType::KeyPress(_));-- // Update global pressed keys- let mut pressed = self.global_pressed.lock().unwrap();-- // If we get a release event for a key that wasn't pressed,- // treat it as a press event instead- if !is_press && !pressed.contains(&key) {- is_press = true;- }-- if is_press {- pressed.insert(key);- } else {- pressed.remove(&key);- }- let pressed_snapshot = pressed.clone();- drop(pressed);-- // Check binding states- let mut active = self.active_bindings.lock().unwrap();- for binding in &self.bindings {- let is_active = active.contains(&binding.id);- let all_required_pressed = binding.keys.is_subset(&pressed_snapshot);- let any_required_key = binding.keys.contains(&key);-- // Only process if this event is for a key we care about- if any_required_key {- match (all_required_pressed, is_active) {- (true, false) => {- (binding.on_press)(&self.context);- active.insert(binding.id.clone());- }- (false, true) => {- // Only trigger release if none of the required keys are pressed- let any_binding_key_pressed =- binding.keys.iter().any(|k| pressed_snapshot.contains(k));-- if !any_binding_key_pressed {- (binding.on_release)(&self.context);- active.remove(&binding.id);- }- }- _ => {}- }- }- }- }- }-}diff --git a/src-tauri/src/managers/mod.rs b/src-tauri/src/managers/mod.rsindex 8a31278a..a61d9ac9 100644--- a/src-tauri/src/managers/mod.rs+++ b/src-tauri/src/managers/mod.rs@@ -1,3 +1,2 @@pub mod audio;-pub mod keybinding;pub mod transcription;diff --git a/src/App.tsx b/src/App.tsxindex 0db8fe76..6a41559a 100644--- a/src/App.tsx+++ b/src/App.tsx@@ -20,6 +20,10 @@ function App() {}setHasAccessibility(hasPermissions);});++ register("ctrl+d", () => {+ console.log("Ctrl+D pressed");+ });}, []);return (