RadrootsAppleMediaPicker.swift (30301B)
1 import Foundation 2 3 #if canImport(AVFoundation) 4 @preconcurrency import AVFoundation 5 #endif 6 7 #if canImport(ImageIO) 8 import ImageIO 9 #endif 10 11 #if canImport(PhotosUI) 12 @preconcurrency import PhotosUI 13 #endif 14 15 #if canImport(UIKit) 16 @preconcurrency import UIKit 17 #endif 18 19 #if canImport(UniformTypeIdentifiers) 20 import UniformTypeIdentifiers 21 #endif 22 23 #if canImport(UIKit) 24 public typealias RadrootsAppleViewControllerProvider = 25 @MainActor @Sendable () throws -> UIViewController 26 #endif 27 28 public final class RadrootsAppleMediaPicker: RadrootsMediaPicker, @unchecked Sendable { 29 private let fileAccess: RadrootsAppleFileAccess 30 private let fileManager: FileManager 31 private let callbackTimeout: TimeInterval 32 33 #if canImport(UIKit) 34 private let viewControllerProvider: RadrootsAppleViewControllerProvider 35 #endif 36 37 #if canImport(UIKit) 38 public init( 39 fileAccess: RadrootsAppleFileAccess, 40 fileManager: FileManager = .default, 41 callbackTimeout: TimeInterval = 120 42 ) { 43 self.fileAccess = fileAccess 44 self.fileManager = fileManager 45 self.callbackTimeout = callbackTimeout 46 viewControllerProvider = { 47 try RadrootsAppleUIKitPresentation.activeViewController(service: "media picker") 48 } 49 } 50 51 public init( 52 fileAccess: RadrootsAppleFileAccess, 53 fileManager: FileManager = .default, 54 callbackTimeout: TimeInterval = 120, 55 viewControllerProvider: @escaping RadrootsAppleViewControllerProvider 56 ) { 57 self.fileAccess = fileAccess 58 self.fileManager = fileManager 59 self.callbackTimeout = callbackTimeout 60 self.viewControllerProvider = viewControllerProvider 61 } 62 #else 63 public init( 64 fileAccess: RadrootsAppleFileAccess, 65 fileManager: FileManager = .default, 66 callbackTimeout: TimeInterval = 120 67 ) { 68 self.fileAccess = fileAccess 69 self.fileManager = fileManager 70 self.callbackTimeout = callbackTimeout 71 } 72 #endif 73 74 public func currentSupport() async throws -> RadrootsMediaPickerSupport { 75 #if canImport(UIKit) && canImport(PhotosUI) 76 try await MainActor.run { 77 try Self.liveSupport() 78 } 79 #else 80 try Self.unavailableSupport() 81 #endif 82 } 83 84 public func importMedia(_ request: RadrootsMediaImportRequest) async throws 85 -> RadrootsMediaImportResult 86 { 87 #if canImport(UIKit) && canImport(PhotosUI) 88 let support = try await currentSupport() 89 guard support.importAvailable else { 90 throw RadrootsCaptureIntakeError.unavailable 91 } 92 let writer = RadrootsAppleMediaAssetWriter( 93 fileAccess: fileAccess, fileManager: fileManager) 94 let presenter: UIViewController 95 do { 96 presenter = try await MainActor.run { 97 try viewControllerProvider() 98 } 99 } catch { 100 throw Self.adapt(error: error) 101 } 102 let coordinatorID = UUID() 103 return try await RadrootsAppleCaptureAsyncSupport.awaitMainActorCallback( 104 timeout: callbackTimeout, 105 timeoutMessage: "timed out while presenting media import" 106 ) { completion, setCleanup in 107 var configuration = PHPickerConfiguration(photoLibrary: .shared()) 108 configuration.selectionLimit = request.selectionLimit 109 configuration.filter = .images 110 let picker = PHPickerViewController(configuration: configuration) 111 let coordinator = RadrootsApplePhotoPickerCoordinator( 112 writer: writer, 113 request: request, 114 coordinatorID: coordinatorID 115 ) 116 coordinator.completion = completion 117 picker.delegate = coordinator 118 setCleanup { 119 coordinator.cancelPresentation(picker) 120 } 121 RadrootsApplePresentationRetainer.shared.store(coordinator, id: coordinatorID) 122 presenter.present(picker, animated: true) 123 } 124 #else 125 throw RadrootsCaptureIntakeError.unavailable 126 #endif 127 } 128 129 public func captureMedia(_ request: RadrootsMediaCaptureRequest) async throws 130 -> RadrootsMediaCaptureResult 131 { 132 #if canImport(UIKit) 133 let support = try await currentSupport() 134 guard support.cameraCaptureAvailable else { 135 throw RadrootsCaptureIntakeError.unavailable 136 } 137 try await Self.requestCameraAccessIfNeeded() 138 let writer = RadrootsAppleMediaAssetWriter( 139 fileAccess: fileAccess, fileManager: fileManager) 140 let presenter: UIViewController 141 do { 142 presenter = try await MainActor.run { 143 try viewControllerProvider() 144 } 145 } catch { 146 throw Self.adapt(error: error) 147 } 148 let coordinatorID = UUID() 149 return try await RadrootsAppleCaptureAsyncSupport.awaitMainActorCallback( 150 timeout: callbackTimeout, 151 timeoutMessage: "timed out while presenting camera photo capture" 152 ) { completion, setCleanup in 153 let picker = UIImagePickerController() 154 picker.sourceType = .camera 155 picker.mediaTypes = [Self.imageTypeIdentifier()] 156 picker.cameraCaptureMode = .photo 157 let coordinator = RadrootsAppleCameraCaptureCoordinator( 158 writer: writer, 159 request: request, 160 coordinatorID: coordinatorID 161 ) 162 coordinator.completion = completion 163 picker.delegate = coordinator 164 setCleanup { 165 coordinator.cancelPresentation(picker) 166 } 167 RadrootsApplePresentationRetainer.shared.store(coordinator, id: coordinatorID) 168 presenter.present(picker, animated: true) 169 } 170 #else 171 throw RadrootsCaptureIntakeError.unavailable 172 #endif 173 } 174 175 static func unavailableSupport() throws -> RadrootsMediaPickerSupport { 176 try RadrootsMediaPickerSupport( 177 importAvailable: false, 178 cameraCaptureAvailable: false, 179 supportedImportKinds: [], 180 supportedCaptureKinds: [], 181 multipleSelectionSupported: false 182 ) 183 } 184 185 static func adapt(error: Error) -> RadrootsCaptureIntakeError { 186 if let captureError = error as? RadrootsCaptureIntakeError { 187 return captureError 188 } 189 if let fileError = error as? RadrootsAppleFileError { 190 return adapt(fileError: fileError) 191 } 192 return RadrootsCaptureIntakeError.transientFailure 193 } 194 195 static func adapt(fileError: RadrootsAppleFileError) -> RadrootsCaptureIntakeError { 196 switch fileError { 197 case .invalidRequest: 198 .invalidRequest 199 case .notFound: 200 .transientFailure 201 case .permissionDenied: 202 .permissionDenied 203 case .transientFailure: 204 .transientFailure 205 case .permanentFailure: 206 .permanentFailure 207 case .spaceInsufficient: 208 .spaceInsufficient 209 } 210 } 211 } 212 213 #if canImport(UIKit) 214 extension RadrootsAppleMediaPicker { 215 @MainActor 216 fileprivate static func liveSupport() throws -> RadrootsMediaPickerSupport { 217 let cameraAvailable = 218 UIImagePickerController.isSourceTypeAvailable(.camera) 219 && UIImagePickerController.availableMediaTypes(for: .camera)?.contains( 220 imageTypeIdentifier()) == true 221 return try RadrootsMediaPickerSupport( 222 importAvailable: true, 223 cameraCaptureAvailable: cameraAvailable, 224 supportedImportKinds: [.image], 225 supportedCaptureKinds: cameraAvailable ? [.image] : [], 226 multipleSelectionSupported: true 227 ) 228 } 229 230 fileprivate static func imageTypeIdentifier() -> String { 231 #if canImport(UniformTypeIdentifiers) 232 UTType.image.identifier 233 #else 234 "public.image" 235 #endif 236 } 237 238 fileprivate static func requestCameraAccessIfNeeded() async throws { 239 #if canImport(AVFoundation) 240 switch AVCaptureDevice.authorizationStatus(for: .video) { 241 case .authorized: 242 return 243 case .notDetermined: 244 let granted = await AVCaptureDevice.requestAccess(for: .video) 245 guard granted else { 246 throw RadrootsCaptureIntakeError.permissionDenied 247 } 248 case .denied: 249 throw RadrootsCaptureIntakeError.permissionDenied 250 case .restricted: 251 throw RadrootsCaptureIntakeError.permissionDenied 252 @unknown default: 253 throw RadrootsCaptureIntakeError.unavailable 254 } 255 #else 256 throw RadrootsCaptureIntakeError.unavailable 257 #endif 258 } 259 } 260 261 @MainActor 262 enum RadrootsAppleUIKitPresentation { 263 static func activeViewController(service: String) throws -> UIViewController { 264 let scenes = UIApplication.shared.connectedScenes 265 .compactMap { $0 as? UIWindowScene } 266 .filter { scene in 267 scene.activationState == .foregroundActive 268 || scene.activationState == .foregroundInactive 269 } 270 let windows = scenes.flatMap(\.windows) 271 guard 272 let window = windows.first(where: \.isKeyWindow) 273 ?? windows.first(where: { !$0.isHidden }) 274 else { 275 throw RadrootsCaptureIntakeError.unavailable 276 } 277 guard let rootViewController = window.rootViewController else { 278 throw RadrootsCaptureIntakeError.unavailable 279 } 280 return topViewController(rootViewController) 281 } 282 283 private static func topViewController(_ viewController: UIViewController) 284 -> UIViewController 285 { 286 if let presentedViewController = viewController.presentedViewController { 287 return topViewController(presentedViewController) 288 } 289 if let navigationController = viewController as? UINavigationController, 290 let visibleViewController = navigationController.visibleViewController 291 { 292 return topViewController(visibleViewController) 293 } 294 if let tabBarController = viewController as? UITabBarController, 295 let selectedViewController = tabBarController.selectedViewController 296 { 297 return topViewController(selectedViewController) 298 } 299 return viewController 300 } 301 } 302 303 @MainActor 304 private final class RadrootsApplePhotoPickerCoordinator: NSObject, 305 PHPickerViewControllerDelegate 306 { 307 var completion: 308 (@Sendable (Result<RadrootsMediaImportResult, RadrootsCaptureIntakeError>) -> Void)? 309 310 private let writer: RadrootsAppleMediaAssetWriter 311 private let request: RadrootsMediaImportRequest 312 private let coordinatorID: UUID 313 private var selectedResults: [PHPickerResult] 314 private var didResolve: Bool 315 316 init( 317 writer: RadrootsAppleMediaAssetWriter, 318 request: RadrootsMediaImportRequest, 319 coordinatorID: UUID 320 ) { 321 self.writer = writer 322 self.request = request 323 self.coordinatorID = coordinatorID 324 selectedResults = [] 325 didResolve = false 326 } 327 328 func picker(_ picker: PHPickerViewController, didFinishPicking results: [PHPickerResult]) { 329 picker.dismiss(animated: true) 330 selectedResults = Array(results.prefix(request.selectionLimit)) 331 guard !selectedResults.isEmpty else { 332 finish(.failure(.userCancelled)) 333 return 334 } 335 loadResult(at: 0, collected: []) 336 } 337 338 private func loadResult(at index: Int, collected: [RadrootsMediaAsset]) { 339 guard index < selectedResults.count else { 340 do { 341 try finish(.success(RadrootsMediaImportResult(items: collected))) 342 } catch { 343 finish(.failure(RadrootsAppleMediaPicker.adapt(error: error))) 344 } 345 return 346 } 347 let provider = selectedResults[index].itemProvider 348 let suggestedName = provider.suggestedName ?? "photo" 349 guard 350 provider.hasItemConformingToTypeIdentifier( 351 RadrootsAppleMediaPicker.imageTypeIdentifier()) 352 else { 353 finish(.failure(.transientFailure)) 354 return 355 } 356 let writer = writer 357 let destinationScope = request.destinationScope 358 let mediaTypeHint = mediaTypeHint(from: provider) 359 provider.loadFileRepresentation( 360 forTypeIdentifier: RadrootsAppleMediaPicker.imageTypeIdentifier() 361 ) { url, error in 362 if let error { 363 Task { @MainActor in 364 self.finish(.failure(RadrootsAppleMediaPicker.adapt(error: error))) 365 } 366 return 367 } 368 guard let url else { 369 Task { @MainActor in 370 self.finish(.failure(.transientFailure)) 371 } 372 return 373 } 374 let result: Result<RadrootsMediaAsset, RadrootsCaptureIntakeError> 375 do { 376 result = try .success( 377 writer.persistExternalImage( 378 sourceURL: url, 379 source: .libraryImport, 380 destinationScope: destinationScope, 381 suggestedFilename: suggestedName, 382 mediaTypeHint: mediaTypeHint 383 ) 384 ) 385 } catch { 386 result = .failure(RadrootsAppleMediaPicker.adapt(error: error)) 387 } 388 Task { @MainActor in 389 switch result { 390 case .success(let asset): 391 var nextCollected = collected 392 nextCollected.append(asset) 393 self.loadResult(at: index + 1, collected: nextCollected) 394 case .failure(let error): 395 self.finish(.failure(error)) 396 } 397 } 398 } 399 } 400 401 private func mediaTypeHint(from provider: NSItemProvider) -> String? { 402 #if canImport(UniformTypeIdentifiers) 403 provider.registeredTypeIdentifiers 404 .compactMap(UTType.init) 405 .first(where: { $0.conforms(to: .image) })? 406 .preferredMIMEType 407 #else 408 nil 409 #endif 410 } 411 412 func cancelPresentation(_ picker: PHPickerViewController) { 413 guard !didResolve else { return } 414 picker.dismiss(animated: true) 415 finish(.failure(.transientFailure)) 416 } 417 418 private func finish(_ result: Result<RadrootsMediaImportResult, RadrootsCaptureIntakeError>) 419 { 420 guard !didResolve else { return } 421 didResolve = true 422 let completion = completion 423 self.completion = nil 424 RadrootsApplePresentationRetainer.shared.release(id: coordinatorID) 425 completion?(result) 426 } 427 } 428 429 @MainActor 430 private final class RadrootsAppleCameraCaptureCoordinator: NSObject, 431 UIImagePickerControllerDelegate, UINavigationControllerDelegate 432 { 433 var completion: 434 (@Sendable (Result<RadrootsMediaCaptureResult, RadrootsCaptureIntakeError>) -> Void)? 435 436 private let writer: RadrootsAppleMediaAssetWriter 437 private let request: RadrootsMediaCaptureRequest 438 private let coordinatorID: UUID 439 private var didResolve: Bool 440 441 init( 442 writer: RadrootsAppleMediaAssetWriter, 443 request: RadrootsMediaCaptureRequest, 444 coordinatorID: UUID 445 ) { 446 self.writer = writer 447 self.request = request 448 self.coordinatorID = coordinatorID 449 didResolve = false 450 } 451 452 func imagePickerControllerDidCancel(_ picker: UIImagePickerController) { 453 picker.dismiss(animated: true) 454 finish(.failure(.userCancelled)) 455 } 456 457 func imagePickerController( 458 _ picker: UIImagePickerController, 459 didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any] 460 ) { 461 picker.dismiss(animated: true) 462 do { 463 try finish(.success(RadrootsMediaCaptureResult(item: buildAsset(info: info)))) 464 } catch { 465 finish(.failure(RadrootsAppleMediaPicker.adapt(error: error))) 466 } 467 } 468 469 private func buildAsset(info: [UIImagePickerController.InfoKey: Any]) throws 470 -> RadrootsMediaAsset 471 { 472 if let imageURL = info[.imageURL] as? URL { 473 return try writer.persistExternalImage( 474 sourceURL: imageURL, 475 source: .cameraCapture, 476 destinationScope: request.destinationScope, 477 suggestedFilename: imageURL.lastPathComponent, 478 mediaTypeHint: nil 479 ) 480 } 481 guard 482 let image = (info[.editedImage] as? UIImage) ?? (info[.originalImage] as? UIImage), 483 let jpegData = image.jpegData(compressionQuality: 0.92) 484 else { 485 throw RadrootsCaptureIntakeError.transientFailure 486 } 487 return try writer.persistCapturedJPEG( 488 data: jpegData, 489 image: image, 490 destinationScope: request.destinationScope 491 ) 492 } 493 494 func cancelPresentation(_ picker: UIImagePickerController) { 495 guard !didResolve else { return } 496 picker.dismiss(animated: true) 497 finish(.failure(.transientFailure)) 498 } 499 500 private func finish( 501 _ result: Result<RadrootsMediaCaptureResult, RadrootsCaptureIntakeError> 502 ) { 503 guard !didResolve else { return } 504 didResolve = true 505 let completion = completion 506 self.completion = nil 507 RadrootsApplePresentationRetainer.shared.release(id: coordinatorID) 508 completion?(result) 509 } 510 } 511 #endif 512 513 @MainActor 514 final class RadrootsApplePresentationRetainer { 515 static let shared = RadrootsApplePresentationRetainer() 516 private var retainers: [UUID: AnyObject] 517 518 private init() { 519 retainers = [:] 520 } 521 522 func store(_ retainer: AnyObject, id: UUID) { 523 retainers[id] = retainer 524 } 525 526 func release(id: UUID) { 527 retainers.removeValue(forKey: id) 528 } 529 } 530 531 private final class RadrootsAppleMediaAssetWriter: @unchecked Sendable { 532 private let fileAccess: RadrootsAppleFileAccess 533 private let fileManager: FileManager 534 535 init(fileAccess: RadrootsAppleFileAccess, fileManager: FileManager) { 536 self.fileAccess = fileAccess 537 self.fileManager = fileManager 538 } 539 540 func persistExternalImage( 541 sourceURL: URL, 542 source: RadrootsMediaSource, 543 destinationScope: RadrootsFileScope, 544 suggestedFilename: String, 545 mediaTypeHint: String? 546 ) throws -> RadrootsMediaAsset { 547 let filename = try sanitizedFilename( 548 suggestedFilename, 549 fallbackBasename: "photo", 550 fallbackExtension: fallbackExtension(mediaType: mediaTypeHint) 551 ) 552 let file = try destinationFile(source: source, scope: destinationScope, filename: filename) 553 let mediaType = try normalizedImageMediaType(mediaTypeHint, filename: filename) 554 let imported = try fileAccess.copyExternalFile( 555 sourceURL, 556 to: file, 557 mediaType: mediaType, 558 suggestedFilename: filename 559 ) 560 let destinationURL = try fileAccess.roots.resolvedURL(for: imported.file) 561 let dimensions = imageDimensions(fileURL: destinationURL) 562 return try RadrootsMediaAsset( 563 source: source, 564 kind: .image, 565 file: imported.file, 566 mediaType: imported.mediaType ?? mediaType, 567 suggestedFilename: imported.suggestedFilename, 568 sizeBytes: imported.sizeBytes, 569 pixelWidth: dimensions?.width, 570 pixelHeight: dimensions?.height, 571 capturedAt: Date() 572 ) 573 } 574 575 #if canImport(UIKit) 576 func persistCapturedJPEG( 577 data: Data, 578 image: UIImage, 579 destinationScope: RadrootsFileScope 580 ) throws -> RadrootsMediaAsset { 581 let filename = try sanitizedFilename( 582 "captured_photo.jpg", 583 fallbackBasename: "captured_photo", 584 fallbackExtension: "jpg" 585 ) 586 let file = try destinationFile( 587 source: .cameraCapture, scope: destinationScope, filename: filename) 588 try fileAccess.write(.inline(data), to: file) 589 return try RadrootsMediaAsset( 590 source: .cameraCapture, 591 kind: .image, 592 file: file, 593 mediaType: "image/jpeg", 594 suggestedFilename: filename, 595 sizeBytes: UInt64(data.count), 596 pixelWidth: image.cgImage.map { UInt32($0.width) } 597 ?? positiveRoundedUInt32(image.size.width), 598 pixelHeight: image.cgImage.map { UInt32($0.height) } 599 ?? positiveRoundedUInt32(image.size.height), 600 capturedAt: Date() 601 ) 602 } 603 #endif 604 605 private func destinationFile( 606 source: RadrootsMediaSource, 607 scope: RadrootsFileScope, 608 filename: String 609 ) throws -> RadrootsFileReference { 610 let namespace = 611 switch source { 612 case .libraryImport: 613 "library_import" 614 case .cameraCapture: 615 "camera_capture" 616 } 617 let validatedFilename = try RadrootsCaptureIntakeValidation.normalizedFilename(filename) 618 return RadrootsFileReference( 619 scope: scope, 620 relativePath: 621 "capture_intake/media/\(namespace)/\(UUID().uuidString.lowercased())/\(validatedFilename)" 622 ) 623 } 624 625 private func sanitizedFilename( 626 _ value: String, 627 fallbackBasename: String, 628 fallbackExtension: String 629 ) throws -> String { 630 let fallback = "\(fallbackBasename).\(fallbackExtension)" 631 let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines) 632 let lastComponent = URL(fileURLWithPath: trimmed).lastPathComponent 633 let raw = lastComponent.isEmpty || lastComponent == "/" ? fallback : lastComponent 634 let sanitizedScalars = raw.unicodeScalars.map { scalar -> Character in 635 if CharacterSet.controlCharacters.contains(scalar) || scalar == "/" || scalar == "\\" 636 || scalar == "\0" || scalar == ":" 637 { 638 return "_" 639 } 640 return Character(scalar) 641 } 642 var sanitized = String(sanitizedScalars).trimmingCharacters(in: .whitespacesAndNewlines) 643 if sanitized.isEmpty || sanitized == "." || sanitized == ".." { 644 sanitized = fallback 645 } 646 if URL(fileURLWithPath: sanitized).pathExtension.isEmpty { 647 sanitized = "\(sanitized).\(fallbackExtension)" 648 } 649 return try RadrootsCaptureIntakeValidation.normalizedFilename(sanitized) 650 } 651 652 private func normalizedImageMediaType(_ mediaType: String?, filename: String) throws -> String { 653 if let mediaType { 654 return try RadrootsCaptureIntakeValidation.normalizedMediaType(mediaType) 655 } 656 #if canImport(UniformTypeIdentifiers) 657 if let type = UTType(filenameExtension: URL(fileURLWithPath: filename).pathExtension), 658 let preferredMIMEType = type.preferredMIMEType 659 { 660 return try RadrootsCaptureIntakeValidation.normalizedMediaType(preferredMIMEType) 661 } 662 #endif 663 return "image/jpeg" 664 } 665 666 private func fallbackExtension(mediaType: String?) -> String { 667 switch mediaType?.lowercased() { 668 case "image/png": 669 "png" 670 case "image/heic": 671 "heic" 672 case "image/heif": 673 "heif" 674 default: 675 "jpg" 676 } 677 } 678 679 private func imageDimensions(fileURL: URL) -> (width: UInt32, height: UInt32)? { 680 #if canImport(ImageIO) 681 guard let imageSource = CGImageSourceCreateWithURL(fileURL as CFURL, nil), 682 let properties = CGImageSourceCopyPropertiesAtIndex(imageSource, 0, nil) 683 as? [CFString: Any], 684 let width = properties[kCGImagePropertyPixelWidth] as? NSNumber, 685 let height = properties[kCGImagePropertyPixelHeight] as? NSNumber, 686 width.uint32Value > 0, 687 height.uint32Value > 0 688 else { 689 return nil 690 } 691 return (width.uint32Value, height.uint32Value) 692 #else 693 return nil 694 #endif 695 } 696 697 private func positiveRoundedUInt32(_ value: Double) -> UInt32? { 698 guard value.isFinite, value > 0 else { 699 return nil 700 } 701 return UInt32(value.rounded()) 702 } 703 } 704 705 enum RadrootsAppleCaptureAsyncSupport { 706 static func awaitMainActorCallback<Value: Sendable>( 707 timeout: TimeInterval, 708 timeoutMessage: String, 709 operation: 710 @escaping @MainActor ( 711 @escaping @Sendable (Result<Value, RadrootsCaptureIntakeError>) -> Void, 712 @escaping @MainActor @Sendable (@escaping @MainActor @Sendable () -> Void) -> Void 713 ) -> Void 714 ) async throws -> Value { 715 guard timeout.isFinite, 716 let nanoseconds = RadrootsAppleTimeConversion.nanoseconds(max(timeout, 0)) 717 else { 718 throw RadrootsCaptureIntakeError.invalidRequest 719 } 720 let state = RadrootsAppleCaptureAsyncCallbackState<Value>() 721 return try await withTaskCancellationHandler { 722 try await withCheckedThrowingContinuation { continuation in 723 state.start(continuation: continuation) 724 let timeoutTask = Task { 725 do { 726 try await Task.sleep(nanoseconds: nanoseconds) 727 } catch { 728 return 729 } 730 state.resolve(.failure(.transientFailure)) 731 } 732 Task { @MainActor in 733 operation( 734 { result in 735 timeoutTask.cancel() 736 state.resolve(result) 737 }, 738 { cleanup in 739 state.setCleanup(cleanup) 740 } 741 ) 742 } 743 } 744 } onCancel: { 745 state.resolve(.failure(.userCancelled)) 746 } 747 } 748 } 749 750 private final class RadrootsAppleCaptureAsyncCallbackState<Value: Sendable>: @unchecked Sendable { 751 private let lock: NSLock 752 private var continuation: CheckedContinuation<Value, any Error>? 753 private var cleanup: (@MainActor @Sendable () -> Void)? 754 private var resolvedResult: Result<Value, RadrootsCaptureIntakeError>? 755 private var didResolve: Bool 756 757 init() { 758 lock = NSLock() 759 continuation = nil 760 cleanup = nil 761 resolvedResult = nil 762 didResolve = false 763 } 764 765 func start(continuation: CheckedContinuation<Value, any Error>) { 766 lock.lock() 767 if let resolvedResult { 768 lock.unlock() 769 resume(continuation, with: resolvedResult) 770 return 771 } 772 self.continuation = continuation 773 lock.unlock() 774 } 775 776 func setCleanup(_ cleanup: @escaping @MainActor @Sendable () -> Void) { 777 lock.lock() 778 let shouldRun = didResolve 779 if !didResolve { 780 self.cleanup = cleanup 781 } 782 lock.unlock() 783 if shouldRun { 784 Task { @MainActor in 785 cleanup() 786 } 787 } 788 } 789 790 func resolve(_ result: Result<Value, RadrootsCaptureIntakeError>) { 791 lock.lock() 792 guard !didResolve else { 793 lock.unlock() 794 return 795 } 796 didResolve = true 797 let continuation = continuation 798 self.continuation = nil 799 if continuation == nil { 800 resolvedResult = result 801 } 802 let cleanup = cleanup 803 self.cleanup = nil 804 lock.unlock() 805 806 if let cleanup { 807 Task { @MainActor in 808 cleanup() 809 } 810 } 811 guard let continuation else { 812 return 813 } 814 resume(continuation, with: result) 815 } 816 817 private func resume( 818 _ continuation: CheckedContinuation<Value, any Error>, 819 with result: Result<Value, RadrootsCaptureIntakeError> 820 ) { 821 switch result { 822 case .success(let value): 823 continuation.resume(returning: value) 824 case .failure(let error): 825 continuation.resume(throwing: error) 826 } 827 } 828 }