refactor(mobile): introduce image request registry on iOS (#27486)

* refactor: replace DispatchQueue + DispatchSemaphore with OperationQueue for image processing

* implement RequestRegistry and UnfairLock for managing cancellable requests

* implement requests registry for local and remote image processing

* remove Cancellable protocol and cancel method from request registry

* use mutex

---------

Co-authored-by: mertalev <101130780+mertalev@users.noreply.github.com>

mobile/ios/Runner/Images/ImageRequest.swift

@@ -0,0 +1,14 @@
+import Foundation
+
+struct RequestRegistry<T: AnyObject & Sendable>: ~Copyable, Sendable {
+  private let requests = Mutex<[Int64: T]>([:])
+
+  func add(requestId: Int64, request: T) {
+    requests.withLock { $0[requestId] = request }
+  }
+
+  @discardableResult
+  func remove(requestId: Int64) -> T? {
+    requests.withLock { $0.removeValue(forKey: requestId) }
+  }
+}

mobile/ios/Runner/Images/LocalImagesImpl.swift

@@ -11,6 +11,11 @@ class LocalImageRequest {
   init(callback: @escaping (Result<[String: Int64]?, any Error>) -> Void) {
     self.callback = callback
   }
+
+  func cancel() {
+    isCancelled = true
+    operation?.cancel()
+  }
 }
 
 class LocalImageApiImpl: LocalImageApi {
@@ -31,9 +36,7 @@ class LocalImageApiImpl: LocalImageApi {
     return requestOptions
   }()
 
-  private static let assetQueue = DispatchQueue(label: "thumbnail.assets", qos: .userInitiated)
-  private static let requestQueue = DispatchQueue(label: "thumbnail.requests", qos: .userInitiated)
-  private static let cancelQueue = DispatchQueue(label: "thumbnail.cancellation", qos: .default)
+  private static let registry = RequestRegistry<LocalImageRequest>()
 
   private static var rgbaFormat = vImage_CGImageFormat(
     bitsPerComponent: 8,
@@ -42,7 +45,6 @@ class LocalImageApiImpl: LocalImageApi {
     bitmapInfo: CGBitmapInfo(rawValue: CGImageAlphaInfo.premultipliedLast.rawValue),
     renderingIntent: .defaultIntent
   )!
-  private static var requests = [Int64: LocalImageRequest]()
   private static let assetCache = {
     let assetCache = NSCache<NSString, PHAsset>()
     assetCache.countLimit = 10000
@@ -73,7 +75,7 @@ class LocalImageApiImpl: LocalImageApi {
 
       guard let asset = Self.requestAsset(assetId: assetId)
       else {
-        Self.remove(requestId: requestId)
+        Self.registry.remove(requestId: requestId)
         completion(.failure(PigeonError(code: "", message: "Could not get asset data for \(assetId)", details: nil)))
         return
       }
@@ -98,12 +100,11 @@ class LocalImageApiImpl: LocalImageApi {
         )
 
         if request.isCancelled {
-          Self.remove(requestId: requestId)
           return completion(ImageProcessing.cancelledResult)
         }
 
         guard let data = imageData else {
-          Self.remove(requestId: requestId)
+          Self.registry.remove(requestId: requestId)
           return completion(.failure(PigeonError(code: "", message: "Could not get image data for \(assetId)", details: nil)))
         }
 
@@ -113,7 +114,6 @@ class LocalImageApiImpl: LocalImageApi {
 
         if request.isCancelled {
           free(pointer)
-          Self.remove(requestId: requestId)
           return completion(ImageProcessing.cancelledResult)
         }
 
@@ -121,7 +121,7 @@ class LocalImageApiImpl: LocalImageApi {
           "pointer": Int64(Int(bitPattern: pointer)),
           "length": Int64(length),
         ]))
-        Self.remove(requestId: requestId)
+        Self.registry.remove(requestId: requestId)
         return
       }
 
@@ -142,7 +142,7 @@ class LocalImageApiImpl: LocalImageApi {
 
       guard let image = image,
             let cgImage = image.cgImage else {
-        Self.remove(requestId: requestId)
+        Self.registry.remove(requestId: requestId)
         return completion(.failure(PigeonError(code: "", message: "Could not get pixel data for \(assetId)", details: nil)))
       }
 
@@ -162,51 +162,32 @@ class LocalImageApiImpl: LocalImageApi {
           "pointer": Int64(Int(bitPattern: buffer.data)),
           "width": Int64(buffer.width),
           "height": Int64(buffer.height),
-          "rowBytes": Int64(buffer.rowBytes)
+          "rowBytes": Int64(buffer.rowBytes),
         ]))
-        Self.remove(requestId: requestId)
+        Self.registry.remove(requestId: requestId)
       } catch {
-        Self.remove(requestId: requestId)
+        Self.registry.remove(requestId: requestId)
         return completion(.failure(PigeonError(code: "", message: "Failed to convert image for \(assetId): \(error)", details: nil)))
       }
     }
 
     request.operation = operation
-    Self.add(requestId: requestId, request: request)
+    Self.registry.add(requestId: requestId, request: request)
     ImageProcessing.queue.addOperation(operation)
   }
 
   func cancelRequest(requestId: Int64) {
-    Self.cancel(requestId: requestId)
-  }
-
-  private static func add(requestId: Int64, request: LocalImageRequest) -> Void {
-    requestQueue.sync { requests[requestId] = request }
-  }
-
-  private static func remove(requestId: Int64) -> Void {
-    requestQueue.sync { requests[requestId] = nil }
-  }
-
-  private static func cancel(requestId: Int64) -> Void {
-    requestQueue.async {
-      guard let request = requests.removeValue(forKey: requestId) else { return }
-      request.isCancelled = true
-      guard let operation = request.operation else { return }
-      if operation.isCancelled {
-        cancelQueue.async { request.callback(ImageProcessing.cancelledResult) }
-      }
-    }
+    Self.registry.remove(requestId: requestId)?.cancel()
   }
 
   private static func requestAsset(assetId: String) -> PHAsset? {
-    var asset: PHAsset?
-    assetQueue.sync { asset = assetCache.object(forKey: assetId as NSString) }
-    if asset != nil { return asset }
+    if let cached = assetCache.object(forKey: assetId as NSString) {
+      return cached
+    }
 
     guard let asset = PHAsset.fetchAssets(withLocalIdentifiers: [assetId], options: Self.fetchOptions).firstObject
     else { return nil }
-    assetQueue.async { assetCache.setObject(asset, forKey: assetId as NSString) }
+    assetCache.setObject(asset, forKey: assetId as NSString)
     return asset
   }
 }

mobile/ios/Runner/Images/RemoteImagesImpl.swift

@@ -14,11 +14,15 @@ class RemoteImageRequest {
     self.task = task
     self.completion = completion
   }
+
+  func cancel() {
+    isCancelled = true
+    task?.cancel()
+  }
 }
 
 class RemoteImageApiImpl: NSObject, RemoteImageApi {
-  private static var lock = os_unfair_lock()
-  private static var requests = [Int64: RemoteImageRequest]()
+  private static let registry = RequestRegistry<RemoteImageRequest>()
   private static var rgbaFormat = vImage_CGImageFormat(
     bitsPerComponent: 8,
     bitsPerPixel: 32,
@@ -43,20 +47,15 @@ class RemoteImageApiImpl: NSObject, RemoteImageApi {
 
     let request = RemoteImageRequest(id: requestId, task: task, completion: completion)
 
-    os_unfair_lock_lock(&Self.lock)
-    Self.requests[requestId] = request
-    os_unfair_lock_unlock(&Self.lock)
+    Self.registry.add(requestId: requestId, request: request)
 
     task.resume()
   }
 
   private static func handleCompletion(requestId: Int64, encoded: Bool, data: Data?, response: URLResponse?, error: Error?) {
-    os_unfair_lock_lock(&Self.lock)
-    guard let request = requests[requestId] else {
-      return os_unfair_lock_unlock(&Self.lock)
+    guard let request = registry.remove(requestId: requestId) else {
+      return
     }
-    requests[requestId] = nil
-    os_unfair_lock_unlock(&Self.lock)
 
     if let error = error {
       if request.isCancelled || (error as NSError).code == NSURLErrorCancelled {
@@ -127,13 +126,7 @@ class RemoteImageApiImpl: NSObject, RemoteImageApi {
   }
 
   func cancelRequest(requestId: Int64) {
-    os_unfair_lock_lock(&Self.lock)
-    let request = Self.requests[requestId]
-    os_unfair_lock_unlock(&Self.lock)
-
-    guard let request = request else { return }
-    request.isCancelled = true
-    request.task?.cancel()
+    Self.registry.remove(requestId: requestId)?.cancel()
   }
 
   func clearCache(completion: @escaping (Result<Int64, any Error>) -> Void) {