0.4 rc1

Author: My Name

Diff for: blaze/main.py

@@ -176,54 +176,117 @@ def isSystemTrayAvailable():
         return QSystemTrayIcon.isSystemTrayAvailable()
 
     def toggle_recording(self):
-        # Check if transcriber is properly initialized
-        if not self.recording and (not hasattr(self, 'transcription_manager') or not self.transcription_manager or
-                                  not hasattr(self.transcription_manager.transcriber, 'model') or not self.transcription_manager.transcriber.model):
-            # Transcriber is not properly initialized, show a message
-            self.ui_manager.show_notification(
-                self,
-                "No Models Downloaded",
-                "No Whisper models are downloaded. Please go to Settings to download a model.",
-                self.normal_icon
-            )
-            # Open settings window to allow user to download a model
-            self.toggle_settings()
+        """Toggle recording state with improved resilience to rapid clicks"""
+        # Use a lock to prevent concurrent execution of this method
+        if hasattr(self, '_recording_lock') and self._recording_lock:
+            logger.info("Recording toggle already in progress, ignoring request")
             return
 
-        if self.recording:
-            # Stop recording
-            self.recording = False
-            self.record_action.setText("Start Recording")
-            self.setIcon(self.normal_icon)
-            
-            # Update progress window before stopping recording
-            if self.progress_window:
-                self.progress_window.set_processing_mode()
-                self.progress_window.set_status("Processing audio...")
-            
-            # Stop the actual recording
-            if self.audio_manager:
-                try:
-                    self.audio_manager.stop_recording()
-                except Exception as e:
-                    logger.error(f"Error stopping recording: {e}")
-                    if self.progress_window:
-                        self.progress_window.close()
-                        self.progress_window = None
-                    return
-        else:
-            # Start recording
-            self.recording = True
-            # Show progress window
-            if not self.progress_window:
+        # Set lock
+        self._recording_lock = True
+        
+        try:
+            # Check if transcriber is properly initialized
+            if not self.recording and (not hasattr(self, 'transcription_manager') or not self.transcription_manager or
+                                      not hasattr(self.transcription_manager.transcriber, 'model') or not self.transcription_manager.transcriber.model):
+                # Transcriber is not properly initialized, show a message
+                self.ui_manager.show_notification(
+                    self,
+                    "No Models Downloaded",
+                    "No Whisper models are downloaded. Please go to Settings to download a model.",
+                    self.normal_icon
+                )
+                # Open settings window to allow user to download a model
+                self.toggle_settings()
+                return
+                
+            # Get current state before changing it (for logging)
+            current_state = "recording" if self.recording else "not recording"
+            new_state = "stop recording" if self.recording else "start recording"
+            logger.info(f"Toggle recording: {current_state} -> {new_state}")
+                
+            if self.recording:
+                # Stop recording
+                # Update UI first to give immediate feedback
+                self.record_action.setText("Start Recording")
+                self.setIcon(self.normal_icon)
+                
+                # Update progress window before stopping recording
+                if self.progress_window:
+                    self.progress_window.set_processing_mode()
+                    self.progress_window.set_status("Processing audio...")
+                
+                # Stop the actual recording
+                if self.audio_manager:
+                    try:
+                        # Only change recording state after successful stop
+                        result = self.audio_manager.stop_recording()
+                        if result:
+                            self.recording = False
+                            logger.info("Recording stopped successfully")
+                        else:
+                            # Revert UI if stop failed
+                            logger.error("Failed to stop recording")
+                            self.record_action.setText("Stop Recording")
+                            self.setIcon(self.recording_icon)
+                    except Exception as e:
+                        logger.error(f"Error stopping recording: {e}")
+                        # Revert UI if exception occurred
+                        self.record_action.setText("Stop Recording")
+                        self.setIcon(self.recording_icon)
+                        if self.progress_window:
+                            self.progress_window.close()
+                            self.progress_window = None
+                else:
+                    # No audio manager, just update state
+                    self.recording = False
+            else:
+                # Start recording
+                # Always create a fresh progress window
+                # Close any existing window first
+                if self.progress_window:
+                    self.ui_manager.safely_close_window(self.progress_window, "before new recording")
+                    self.progress_window = None
+                
+                # Create a new progress window
                 self.progress_window = ProgressWindow("Voice Recording")
                 self.progress_window.stop_clicked.connect(self._stop_recording)
-            self.progress_window.show()
-            
-            # Start recording
-            self.record_action.setText("Stop Recording")
-            self.setIcon(self.recording_icon)
-            self.audio_manager.start_recording()
+                self.progress_window.show()
+                
+                # Update UI to give immediate feedback
+                self.record_action.setText("Stop Recording")
+                self.setIcon(self.recording_icon)
+                
+                # Start the actual recording
+                if self.audio_manager:
+                    try:
+                        # Only change recording state after successful start
+                        result = self.audio_manager.start_recording()
+                        if result:
+                            self.recording = True
+                            logger.info("Recording started successfully")
+                        else:
+                            # Revert UI if start failed
+                            logger.error("Failed to start recording")
+                            self.record_action.setText("Start Recording")
+                            self.setIcon(self.normal_icon)
+                            if self.progress_window:
+                                self.progress_window.close()
+                                self.progress_window = None
+                    except Exception as e:
+                        logger.error(f"Error starting recording: {e}")
+                        # Revert UI if exception occurred
+                        self.record_action.setText("Start Recording")
+                        self.setIcon(self.normal_icon)
+                        if self.progress_window:
+                            self.progress_window.close()
+                            self.progress_window = None
+                else:
+                    # No audio manager, just update state
+                    self.recording = True
+        finally:
+            # Always release the lock
+            self._recording_lock = False
 
     def _stop_recording(self):
         """Internal method to stop recording and start processing"""
@@ -279,21 +342,42 @@ def update_tooltip(self, recognized_text=None):
     # Removed update_shortcuts method as part of keyboard shortcut functionality removal
 
     def on_activate(self, reason):
-        if reason == QSystemTrayIcon.ActivationReason.Trigger:  # Left click
-            # Check if transcriber is properly initialized
-            if hasattr(self, 'transcription_manager') and self.transcription_manager and hasattr(self.transcription_manager.transcriber, 'model') and self.transcription_manager.transcriber.model:
-                # Transcriber is properly initialized, proceed with recording
-                self.toggle_recording()
-            else:
-                # Transcriber is not properly initialized, show a message
-                self.ui_manager.show_notification(
-                    self,
-                    "No Models Downloaded",
-                    "No Whisper models are downloaded. Please go to Settings to download a model.",
-                    self.normal_icon
-                )
-                # Open settings window to allow user to download a model
-                self.toggle_settings()
+        """Handle tray icon activation with improved resilience"""
+        # Ignore activations if we're already processing a click
+        if hasattr(self, '_activation_lock') and self._activation_lock:
+            logger.info("Activation already in progress, ignoring request")
+            return
+            
+        # Set lock
+        self._activation_lock = True
+        
+        try:
+            if reason == QSystemTrayIcon.ActivationReason.Trigger:  # Left click
+                logger.info("Tray icon left-clicked")
+                
+                # Check if we're in the middle of processing a recording
+                if hasattr(self, 'progress_window') and self.progress_window and self.progress_window.isVisible():
+                    if not self.recording and getattr(self.progress_window, 'processing', False):
+                        logger.info("Processing in progress, ignoring activation")
+                        return
+                
+                # Check if transcriber is properly initialized
+                if hasattr(self, 'transcription_manager') and self.transcription_manager and hasattr(self.transcription_manager.transcriber, 'model') and self.transcription_manager.transcriber.model:
+                    # Transcriber is properly initialized, proceed with recording
+                    self.toggle_recording()
+                else:
+                    # Transcriber is not properly initialized, show a message
+                    self.ui_manager.show_notification(
+                        self,
+                        "No Models Downloaded",
+                        "No Whisper models are downloaded. Please go to Settings to download a model.",
+                        self.normal_icon
+                    )
+                    # Open settings window to allow user to download a model
+                    self.toggle_settings()
+        finally:
+            # Always release the lock
+            self._activation_lock = False
 
     def quit_application(self):
         try:
@@ -426,6 +510,8 @@ def _close_progress_window(self, context=""):
         """Helper method to safely close progress window"""
         if self.progress_window:
             self.ui_manager.safely_close_window(self.progress_window, f"progress {context}")
+            # Explicitly set to None to force recreation on next recording
+            self.progress_window = None
         else:
             logger.warning(f"Progress window not found when trying to close {context}".strip())
 

Diff for: blaze/managers/audio_manager.py

@@ -6,6 +6,7 @@
 """
 
 import logging
+import time
 from PyQt6.QtCore import QObject, pyqtSignal
 
 logger = logging.getLogger(__name__)
@@ -57,7 +58,7 @@ def initialize(self):
             return False
 
     def start_recording(self):
-        """Start audio recording
+        """Start audio recording with improved error handling
         
         Returns:
         --------
@@ -74,7 +75,20 @@ def start_recording(self):
             return True
 
         try:
+            # Check if recorder is ready
+            if not hasattr(self.recorder, 'start_recording'):
+                logger.error("Recorder object does not have start_recording method")
+                self.recording_failed.emit("Invalid recorder object")
+                return False
+                
+            # Start recording with timeout protection
+            start_time = time.time()
             self.recorder.start_recording()
+            
+            # Verify recording started within reasonable time
+            if time.time() - start_time > 2.0:  # More than 2 seconds is suspicious
+                logger.warning("Recording start took unusually long time")
+                
             self.is_recording = True
             logger.info("Recording started")
             return True
@@ -84,7 +98,7 @@ def start_recording(self):
             return False
 
     def stop_recording(self):
-        """Stop audio recording
+        """Stop audio recording with improved error handling
         
         Returns:
         --------
@@ -100,7 +114,20 @@ def stop_recording(self):
             return True
 
         try:
+            # Check if recorder is ready
+            if not hasattr(self.recorder, '_stop_recording'):
+                logger.error("Recorder object does not have _stop_recording method")
+                self.recording_failed.emit("Invalid recorder object")
+                return False
+                
+            # Stop recording with timeout protection
+            start_time = time.time()
             self.recorder._stop_recording()
+            
+            # Verify recording stopped within reasonable time
+            if time.time() - start_time > 2.0:  # More than 2 seconds is suspicious
+                logger.warning("Recording stop took unusually long time")
+                
             self.is_recording = False
             logger.info("Recording stopped")
             return True

Diff for: blaze/managers/ui_manager.py

@@ -63,8 +63,17 @@ def safely_close_window(self, window, window_name=""):
 
         try:
             logger.info(f"Closing {window_name} window")
+            
+            # Reset any processing state if it exists
+            if hasattr(window, 'processing'):
+                window.processing = False
+            
+            # Hide first to give immediate visual feedback
             window.hide()
+            
+            # Then close and schedule for deletion
             window.close()
+            window.deleteLater()
 
             # Force an immediate process of events
             QApplication.processEvents()