Update the sync between keyboard extension and the main app

Author: Beingpax

VoiceInk-ios.xcodeproj/project.xcworkspace/xcuserdata/beingpax.xcuserdatad/UserInterfaceState.xcuserstate

@@ -69,17 +69,32 @@ final class AppGroupCoordinator {
 
     /// Get current recording state (for keyboard UI updates)
     var isRecording: Bool {
-        return sharedDefaults?.bool(forKey: UserDefaultsKeys.isRecording) ?? false
+        let storedState = sharedDefaults?.bool(forKey: UserDefaultsKeys.isRecording) ?? false
+        let timestamp = sharedDefaults?.double(forKey: UserDefaultsKeys.lastRecordingTimestamp) ?? 0
+        let currentTime = Date().timeIntervalSince1970
+        
+        // If the stored state is more than 30 seconds old, consider it stale
+        if storedState && (currentTime - timestamp) > 30 {
+            print("⚠️ Recording state appears stale, clearing it")
+            updateRecordingState(false)
+            return false
+        }
+        
+        return storedState
     }
 
     // MARK: - Public Interface for Main App
 
     /// Call this from the main app to update recording state
     func updateRecordingState(_ isRecording: Bool) {
         sharedDefaults?.set(isRecording, forKey: UserDefaultsKeys.isRecording)
+        // Update timestamp whenever state changes
+        sharedDefaults?.set(Date().timeIntervalSince1970, forKey: UserDefaultsKeys.lastRecordingTimestamp)
 
         // Notify keyboard of state change
         postDarwinNotification(NotificationNames.recordingStateChanged)
+        
+        print("📡 Updated recording state: \(isRecording)")
     }
 
     /// Check and consume start recording flag (returns true if should start)

VoiceInk-ios/AppGroupCoordinator.swift

@@ -29,11 +29,11 @@ final class AudioSessionManager: ObservableObject {
         let audioSession = AVAudioSession.sharedInstance()
 
         do {
-            // Configure session for foreground recording only
+            // Configure session for recording with background support
             try audioSession.setCategory(
                 .playAndRecord,
                 mode: .spokenAudio,
-                options: [.defaultToSpeaker, .allowBluetooth, .allowBluetoothA2DP]
+                options: [.defaultToSpeaker, .allowBluetooth, .allowBluetoothA2DP, .mixWithOthers]
             )
 
             // Activate the session

VoiceInk-ios/AudioSessionManager.swift

@@ -18,5 +18,9 @@
 			</array>
 		</dict>
 	</array>
+	<key>UIBackgroundModes</key>
+	<array>
+		<string>audio</string>
+	</array>
 </dict>
 </plist>

VoiceInk-ios/Info.plist

@@ -87,6 +87,11 @@ struct NotesListView: View {
                         )
                     }
                 }
+                .onReceive(NotificationCenter.default.publisher(for: .stopRecordingFromKeyboard)) { _ in
+                    if recordingManager.isRecording {
+                        recordingManager.stopRecording(modelContext: modelContext)
+                    }
+                }
         }
     }
 

VoiceInk-ios/NotesListView.swift

@@ -4,6 +4,10 @@ import AVFoundation
 import Combine
 import UIKit
 
+extension Notification.Name {
+    static let stopRecordingFromKeyboard = Notification.Name("stopRecordingFromKeyboard")
+}
+
 enum RecordingState: Equatable {
     case idle
     case recording
@@ -45,6 +49,7 @@ final class RecordingManager: ObservableObject {
     private var durationTimer: Timer?
 
     private let sessionManager = AudioSessionManager.shared
+    private let coordinator = AppGroupCoordinator.shared
 
     var isRecording: Bool {
         recordingState == .recording
@@ -54,12 +59,24 @@ final class RecordingManager: ObservableObject {
     init() {
         // Simplified initialization - no complex keyboard coordination needed
         print("🎙️ RecordingManager initialized")
+        setupCoordinatorCallbacks()
     }
 
     deinit {
         durationTimer?.invalidate()
     }
 
+    // MARK: - Coordinator Setup
+    private func setupCoordinatorCallbacks() {
+        coordinator.onStopRecordingRequested = { [weak self] in
+            guard let self = self, self.isRecording else { return }
+            // This will be called when keyboard extension requests stop
+            print("🛑 Stop recording requested from keyboard extension")
+            // We need modelContext, so we'll handle this via a notification instead
+            NotificationCenter.default.post(name: .stopRecordingFromKeyboard, object: nil)
+        }
+    }
+    
     // MARK: - Recording Flow (Simplified)
 
 
@@ -86,6 +103,9 @@ final class RecordingManager: ObservableObject {
         recordingState = .recording
         animate = true
 
+        // Update coordinator state
+        coordinator.updateRecordingState(true)
+        
         // Auto-select first mode if none is selected
         if settings.selectedModeId == nil && !settings.modes.isEmpty {
             settings.selectedModeId = settings.modes.first?.id
@@ -99,6 +119,8 @@ final class RecordingManager: ObservableObject {
             activeRecordingAlert = .generic(error)
             recordingState = .idle
             animate = false
+            // Update coordinator state on error
+            coordinator.updateRecordingState(false)
         }
     }
 
@@ -128,6 +150,9 @@ final class RecordingManager: ObservableObject {
         currentRecordingNote = note
         isRecordingSheetPresented = false
 
+        // Update coordinator state
+        coordinator.updateRecordingState(false)
+        
         // Start background transcription
         transcribeInBackground(note: note, audioFileName: audioFileName, recordingDuration: recordingDuration, modelContext: modelContext)
     }
@@ -139,6 +164,9 @@ final class RecordingManager: ObservableObject {
         animate = false
         isRecordingSheetPresented = false
         currentDuration = 0
+        
+        // Update coordinator state
+        coordinator.updateRecordingState(false)
     }
 
     // MARK: - Permissions

VoiceInk-ios/RecordingManager.swift

@@ -13,6 +13,12 @@ struct VoiceInk_iosApp: App {
     @State private var hasCompletedOnboarding = UserDefaults.standard.bool(forKey: "hasCompletedOnboarding")
     @StateObject private var recordingManager = RecordingManager()
 
+    init() {
+        // Clear any stale recording state on app launch
+        AppGroupCoordinator.shared.updateRecordingState(false)
+        print("🧹 Cleared stale recording state on app launch")
+    }
+    
     var sharedModelContainer: ModelContainer = {
         let schema = Schema([
             Transcription.self,

VoiceInk-ios/VoiceInk_iosApp.swift

@@ -11,10 +11,18 @@ import KeyboardKit
 class KeyboardViewController: KeyboardInputViewController {
 
     var recordButton: UIButton!
+    private let coordinator = AppGroupCoordinator.shared
+    private var recordingStatusTimer: Timer?
+    
+    deinit {
+        recordingStatusTimer?.invalidate()
+        recordingStatusTimer = nil
+    }
 
     override func viewDidLoad() {
         super.viewDidLoad()
         setupKeyboard()
+        setupRecordingStatusMonitoring()
     }
 
     private func setupKeyboard() {
@@ -47,38 +55,77 @@ class KeyboardViewController: KeyboardInputViewController {
     }
 
     private func setupRecordButton() {
-        // Create the capsule-shaped record button
+        // Create the native iOS-style record button
         recordButton = UIButton(type: .system)
-        recordButton.setTitle("🎤 Record", for: .normal)
-        recordButton.titleLabel?.font = UIFont.systemFont(ofSize: 12, weight: .medium)
-        recordButton.backgroundColor = UIColor.systemRed
-        recordButton.setTitleColor(.white, for: .normal)
-        recordButton.layer.cornerRadius = 14 // Will be adjusted to make it capsule-shaped
         recordButton.translatesAutoresizingMaskIntoConstraints = false
         recordButton.addTarget(self, action: #selector(recordButtonTapped), for: .touchUpInside)
 
-        // Add some padding and styling for better appearance
-        recordButton.contentEdgeInsets = UIEdgeInsets(top: 4, left: 10, bottom: 4, right: 10)
+        // Configure for idle state initially
+        configureButtonForIdleState()
+        
+        // Add native iOS styling
+        recordButton.titleLabel?.font = UIFont.systemFont(ofSize: 14, weight: .semibold)
+        recordButton.contentEdgeInsets = UIEdgeInsets(top: 6, left: 16, bottom: 6, right: 16)
+        
+        // Native iOS shadow and styling
         recordButton.layer.shadowColor = UIColor.black.cgColor
         recordButton.layer.shadowOffset = CGSize(width: 0, height: 1)
-        recordButton.layer.shadowOpacity = 0.15
-        recordButton.layer.shadowRadius = 1.5
+        recordButton.layer.shadowOpacity = 0.2
+        recordButton.layer.shadowRadius = 2
+        
+        // Add subtle border for better definition
+        recordButton.layer.borderWidth = 0.5
+        recordButton.layer.borderColor = UIColor.separator.cgColor
 
         // Add button to main view
         view.addSubview(recordButton)
 
         // Set up constraints - position in top center with safe margins
         NSLayoutConstraint.activate([
             recordButton.centerXAnchor.constraint(equalTo: view.centerXAnchor),
-            recordButton.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 4),
-            recordButton.heightAnchor.constraint(equalToConstant: 28),
-            recordButton.widthAnchor.constraint(greaterThanOrEqualToConstant: 80)
+            recordButton.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor, constant: 6),
+            recordButton.heightAnchor.constraint(equalToConstant: 32),
+            recordButton.widthAnchor.constraint(greaterThanOrEqualToConstant: 120)
         ])
 
         // Ensure button stays on top
         view.bringSubviewToFront(recordButton)
     }
 
+    private func configureButtonForIdleState() {
+        // Use SF Symbol for microphone
+        let microphoneConfig = UIImage.SymbolConfiguration(pointSize: 14, weight: .semibold)
+        let microphoneImage = UIImage(systemName: "mic.fill", withConfiguration: microphoneConfig)
+        
+        recordButton.setImage(microphoneImage, for: .normal)
+        recordButton.setTitle(" Record", for: .normal)
+        recordButton.backgroundColor = UIColor.systemBlue
+        recordButton.setTitleColor(.white, for: .normal)
+        recordButton.tintColor = .white
+        
+        // Ensure image and text are properly aligned
+        recordButton.semanticContentAttribute = .forceLeftToRight
+        recordButton.imageEdgeInsets = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 4)
+        recordButton.titleEdgeInsets = UIEdgeInsets(top: 0, left: 4, bottom: 0, right: 0)
+    }
+    
+    private func configureButtonForRecordingState() {
+        // Use SF Symbol for stop
+        let stopConfig = UIImage.SymbolConfiguration(pointSize: 14, weight: .semibold)
+        let stopImage = UIImage(systemName: "stop.fill", withConfiguration: stopConfig)
+        
+        recordButton.setImage(stopImage, for: .normal)
+        recordButton.setTitle(" Stop", for: .normal)
+        recordButton.backgroundColor = UIColor.systemRed
+        recordButton.setTitleColor(.white, for: .normal)
+        recordButton.tintColor = .white
+        
+        // Ensure image and text are properly aligned
+        recordButton.semanticContentAttribute = .forceLeftToRight
+        recordButton.imageEdgeInsets = UIEdgeInsets(top: 0, left: 0, bottom: 0, right: 4)
+        recordButton.titleEdgeInsets = UIEdgeInsets(top: 0, left: 4, bottom: 0, right: 0)
+    }
+    
     override func viewDidAppear(_ animated: Bool) {
         super.viewDidAppear(animated)
 
@@ -120,14 +167,32 @@ class KeyboardViewController: KeyboardInputViewController {
     }
 
     @objc private func recordButtonTapped() {
+        // Add native iOS button press animation
+        addButtonPressAnimation()
 
         // Provide haptic feedback
         let impactFeedback = UIImpactFeedbackGenerator(style: .medium)
         impactFeedback.impactOccurred()
 
-        // Simply open the main app for recording
-        // No more complex coordination - just switch to main app
-        openMainAppForRecording()
+        if coordinator.isRecording {
+            // Stop recording
+            coordinator.requestStopRecording()
+            updateButtonAppearanceBasedOnState()
+        } else {
+            // Start recording by opening main app
+            openMainAppForRecording()
+        }
+    }
+    
+    private func addButtonPressAnimation() {
+        // Native iOS button press animation - scale down then back up
+        UIView.animate(withDuration: 0.1, delay: 0, options: [.curveEaseInOut], animations: {
+            self.recordButton.transform = CGAffineTransform(scaleX: 0.95, y: 0.95)
+        }) { _ in
+            UIView.animate(withDuration: 0.1, delay: 0, options: [.curveEaseInOut], animations: {
+                self.recordButton.transform = CGAffineTransform.identity
+            })
+        }
     }
 
     private func openMainAppForRecording() {
@@ -194,22 +259,47 @@ class KeyboardViewController: KeyboardInputViewController {
 
     private func showUserMessage() {
         // Last resort: Update button to show user should open main app manually
-        recordButton.setTitle("📱 Open VoiceInk", for: .normal)
-        recordButton.backgroundColor = UIColor.systemBlue
+        let appConfig = UIImage.SymbolConfiguration(pointSize: 14, weight: .semibold)
+        let appImage = UIImage(systemName: "app", withConfiguration: appConfig)
+        
+        recordButton.setImage(appImage, for: .normal)
+        recordButton.setTitle(" Open VoiceInk", for: .normal)
+        recordButton.backgroundColor = UIColor.systemOrange
+        recordButton.setTitleColor(.white, for: .normal)
+        recordButton.tintColor = .white
 
         DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
-            self.recordButton.setTitle("🎤 Record", for: .normal)
-            self.recordButton.backgroundColor = UIColor.systemRed
+            self.configureButtonForIdleState()
+        }
+    }
+    
+    private func setupRecordingStatusMonitoring() {
+        // Monitor recording status every 0.5 seconds
+        recordingStatusTimer = Timer.scheduledTimer(withTimeInterval: 0.5, repeats: true) { [weak self] _ in
+            self?.updateButtonAppearanceBasedOnState()
         }
+        
+        // Initial state update
+        updateButtonAppearanceBasedOnState()
     }
 
     private func updateButtonAppearanceBasedOnState() {
-        // Simplified: Always show "Record" since we just open the main app
-        recordButton.backgroundColor = UIColor.systemRed
-        recordButton.setTitle("🎤 Record", for: .normal)
+        let isRecording = coordinator.isRecording
 
-        // Ensure capsule shape is maintained
-        recordButton.layer.cornerRadius = recordButton.frame.height / 2
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self, let button = self.recordButton else { return }
+            
+            if isRecording {
+                // Configure for recording state
+                self.configureButtonForRecordingState()
+            } else {
+                // Configure for idle state
+                self.configureButtonForIdleState()
+            }
+            
+            // Ensure capsule shape is maintained
+            button.layer.cornerRadius = button.frame.height / 2
+        }
     }
 
     override func textWillChange(_ textInput: UITextInput?) {