feat: Update authorization request methods to use async/await pattern for improved concurrency

Author: tattn

app/xcode/Sources/VCamTracking/AudioManager.swift

@@ -7,7 +7,7 @@ public final class AudioManager {
     public init() {}
 
     public static var isMicrophoneAuthorized: () -> Bool = { false }
-    public static var requestMicrophonePermission: (@escaping ((Bool) -> Void)) -> Void = { _ in }
+    public static var requestMicrophonePermission: @MainActor () async -> Bool = { false }
 
     private var onUpdateAudioBuffer: (@Sendable (AVAudioPCMBuffer, AVAudioTime, TimeInterval) -> Void)?
 
@@ -24,11 +24,9 @@ public final class AudioManager {
     public func startRecording(onStart: @Sendable @escaping (AVAudioFormat) -> Void) {
         guard Self.isMicrophoneAuthorized() else {
             Logger.log("requestAuthorization")
-            Self.requestMicrophonePermission { [weak self] authorized in
-                guard authorized else { return }
-                Task { @MainActor in
-                    self?.startRecording(onStart: onStart)
-                }
+            Task {
+                guard await Self.requestMicrophonePermission() else { return }
+                startRecording(onStart: onStart)
             }
             return
         }

app/xcode/Sources/VCamTracking/AvatarCameraManager.swift

@@ -11,15 +11,15 @@ public final class AvatarCameraManager {
 
     private struct PermissionState: Sendable {
         var isCameraAuthorized: @Sendable () -> Bool = { false }
-        var requestCameraPermission: @Sendable (@escaping @Sendable (Bool) -> Void) -> Void = { _ in }
+        var requestCameraPermission: @Sendable @MainActor () async -> Bool = { false }
     }
 
     public nonisolated static var isCameraAuthorized: @Sendable () -> Bool {
         get { permissionStorage.withLock { $0.isCameraAuthorized } }
         set { permissionStorage.withLock { $0.isCameraAuthorized = newValue } }
     }
 
-    public nonisolated static var requestCameraPermission: @Sendable (@escaping @Sendable (Bool) -> Void) -> Void {
+    public nonisolated static var requestCameraPermission: @Sendable @MainActor () async -> Bool {
         get { permissionStorage.withLock { $0.requestCameraPermission } }
         set { permissionStorage.withLock { $0.requestCameraPermission = newValue } }
     }
@@ -47,11 +47,9 @@ public final class AvatarCameraManager {
         if Self.isCameraAuthorized() {
             webCamera.start()
         } else {
-            Self.requestCameraPermission { [weak self] authorized in
-                guard authorized else { return }
-                DispatchQueue.runOnMain {
-                    self?.webCamera.start()
-                }
+            Task {
+                guard await Self.requestCameraPermission() else { return }
+                webCamera.start()
             }
         }
     }

app/xcode/Sources/VCamUI/DeviceAuthorization.swift

@@ -41,29 +41,22 @@ public enum DeviceAuthorization {
         AVCaptureDevice.authorizationStatus(for: type.mediaType) == .authorized
     }
 
-    public static func requestAuthorization(type: AuthorizationType, completion: @escaping @Sendable (Bool) -> Void) {
+    @MainActor
+    public static func requestAuthorization(type: AuthorizationType) async -> Bool {
         switch AVCaptureDevice.authorizationStatus(for: type.mediaType) {
         case .authorized:
-            completion(true)
+            return true
 
         case .notDetermined:
-            let authType = type
-            let completion = completion
-            AVCaptureDevice.requestAccess(for: type.mediaType) { _ in
-                Task { @MainActor in
-                    requestAuthorization(type: authType, completion: completion)
-                }
-            }
+            await AVCaptureDevice.requestAccess(for: type.mediaType)
+            return await requestAuthorization(type: type)
 
         case .denied, .restricted:
-            let authType = type
-            let completion = completion
-            Task { @MainActor in
-                await showAuthorizationError(type: authType)
-                completion(false)
-            }
+            await showAuthorizationError(type: type)
+            return false
+
         @unknown default:
-            completion(false)
+            return false
         }
     }