apple_kit

Apple-native services for Radroots iOS and macOS apps
git clone https://radroots.dev/git/apple_kit.git
Log | Files | Refs | README | LICENSE

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 }