Match Philo microphone permission flow

Use Philo-style AVFoundation checks for microphone status and requests, remove the old Swift microphone bridge, and align microphone permission copy.

Author: ComputelessComputer

src-tauri/Cargo.lock

@@ -37,6 +37,9 @@ aec3 = "0.1.7"
 swift-rs = { version = "1.0.7", features = ["build"] }
 
 [target.'cfg(target_os = "macos")'.dependencies]
+block2 = "0.6.2"
+objc2 = "0.6.3"
+objc2-av-foundation = "0.3.2"
 swift-rs = "1.0.7"
 cidre = { version = "0.15", features = ["av"] }
 rodio = "0.22"

src-tauri/Cargo.toml

@@ -1,14 +1,14 @@
 use serde::{Deserialize, Serialize};
 
 #[cfg(target_os = "macos")]
-use cidre::{cf, core_audio as ca, ns, os};
+use block2::RcBlock;
 #[cfg(target_os = "macos")]
-use swift_rs::{swift, Bool, Int};
-
+use cidre::{cf, core_audio as ca, ns, os};
 #[cfg(target_os = "macos")]
-swift!(fn _microphone_permission_status() -> Int);
+use objc2_av_foundation::{AVAuthorizationStatus, AVCaptureDevice, AVMediaTypeAudio};
 #[cfg(target_os = "macos")]
-swift!(fn _request_microphone_permission() -> Bool);
+use swift_rs::{swift, Int};
+
 #[cfg(target_os = "macos")]
 swift!(fn _audio_capture_permission_status() -> Int);
 
@@ -55,16 +55,17 @@ pub fn snapshot() -> Result<PermissionSnapshot, String> {
 pub fn check(permission: PermissionKind) -> Result<PermissionStatus, String> {
     #[cfg(target_os = "macos")]
     {
-        let raw = match permission {
-            PermissionKind::Microphone => unsafe { _microphone_permission_status() as isize },
-            PermissionKind::SystemAudio => unsafe { _audio_capture_permission_status() as isize },
-        };
-
-        Ok(match raw {
-            GRANTED => PermissionStatus::Authorized,
-            NEVER_REQUESTED => PermissionStatus::NeverRequested,
-            DENIED => PermissionStatus::Denied,
-            _ => PermissionStatus::Denied,
+        Ok(match permission {
+            PermissionKind::Microphone => check_microphone(),
+            PermissionKind::SystemAudio => {
+                let raw = unsafe { _audio_capture_permission_status() as isize };
+                match raw {
+                    GRANTED => PermissionStatus::Authorized,
+                    NEVER_REQUESTED => PermissionStatus::NeverRequested,
+                    DENIED => PermissionStatus::Denied,
+                    _ => PermissionStatus::Denied,
+                }
+            }
         })
     }
 
@@ -79,7 +80,10 @@ pub fn request(permission: PermissionKind) -> Result<PermissionStatus, String> {
     #[cfg(target_os = "macos")]
     {
         let granted = match permission {
-            PermissionKind::Microphone => unsafe { _request_microphone_permission() },
+            PermissionKind::Microphone => {
+                request_microphone();
+                true
+            }
             PermissionKind::SystemAudio => {
                 request_system_audio_probe()?;
                 true
@@ -120,6 +124,35 @@ pub fn open_settings(permission: PermissionKind) -> Result<(), String> {
     Ok(())
 }
 
+#[cfg(target_os = "macos")]
+fn check_microphone() -> PermissionStatus {
+    let status = unsafe {
+        let media_type = AVMediaTypeAudio.unwrap();
+        AVCaptureDevice::authorizationStatusForMediaType(media_type)
+    };
+
+    match status {
+        AVAuthorizationStatus::NotDetermined => PermissionStatus::NeverRequested,
+        AVAuthorizationStatus::Authorized => PermissionStatus::Authorized,
+        _ => PermissionStatus::Denied,
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn request_microphone() {
+    let (tx, rx) = std::sync::mpsc::channel::<bool>();
+    let completion = RcBlock::new(move |granted: objc2::runtime::Bool| {
+        let _ = tx.send(granted.as_bool());
+    });
+
+    unsafe {
+        let media_type = AVMediaTypeAudio.unwrap();
+        AVCaptureDevice::requestAccessForMediaType_completionHandler(media_type, &completion);
+    }
+
+    let _ = rx.recv_timeout(std::time::Duration::from_secs(60));
+}
+
 #[cfg(target_os = "macos")]
 fn request_system_audio_probe() -> Result<(), String> {
     let stop_silence = play_silence();

src-tauri/src/permissions.rs

@@ -1,4 +1,3 @@
-import AVFoundation
 import Foundation
 
 private let grantedValue = 0
@@ -14,49 +13,6 @@ private let tccHandle: UnsafeMutableRawPointer? = {
 
 private typealias TCCPreflightFunc = @convention(c) (CFString, CFDictionary?) -> Int
 
-private func mapCaptureMicrophoneStatus(_ status: AVAuthorizationStatus) -> Int {
-  switch status {
-  case .authorized:
-    grantedValue
-  case .notDetermined:
-    neverRequestedValue
-  case .denied, .restricted:
-    deniedValue
-  @unknown default:
-    errorValue
-  }
-}
-
-@_cdecl("_microphone_permission_status")
-public func _microphone_permission_status() -> Int {
-  mapCaptureMicrophoneStatus(AVCaptureDevice.authorizationStatus(for: .audio))
-}
-
-@_cdecl("_request_microphone_permission")
-public func _request_microphone_permission() -> Bool {
-  let status = AVCaptureDevice.authorizationStatus(for: .audio)
-
-  switch status {
-  case .authorized:
-    return true
-  case .denied, .restricted:
-    return false
-  case .notDetermined:
-    let semaphore = DispatchSemaphore(value: 0)
-    var granted = false
-
-    AVCaptureDevice.requestAccess(for: .audio) { allowed in
-      granted = allowed
-      semaphore.signal()
-    }
-
-    _ = semaphore.wait(timeout: .now() + .seconds(60))
-    return granted
-  @unknown default:
-    return false
-  }
-}
-
 @_cdecl("_audio_capture_permission_status")
 public func _audio_capture_permission_status() -> Int {
   guard let tccHandle,

src-tauri/swift-permissions/src/lib.swift

@@ -1914,10 +1914,18 @@ function permissionHostHint(permission: PermissionKind) {
 }
 
 function permissionDeniedMessage(permission: PermissionKind) {
+  if (permission === "microphone") {
+    return `Microphone access is required to record meetings. Allow the app in System Settings > Privacy & Security > Microphone.${permissionHostHint(permission)}`;
+  }
+
   return `${permissionLabel(permission)} access is off. Enable it in System Settings and try again.${permissionHostHint(permission)}`;
 }
 
 function permissionPendingMessage(permission: PermissionKind) {
+  if (permission === "microphone") {
+    return `Microphone permission request did not finish. Try recording again and allow access when prompted.${permissionHostHint(permission)}`;
+  }
+
   return `${permissionLabel(permission)} permission request did not finish. Try again and allow access when prompted.${permissionHostHint(permission)}`;
 }