@amazon-devices/expo-image 2.0.1758683737

package/ios/ImageModule.swift

@@ -0,0 +1,127 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import SDWebImage
+import SDWebImageWebPCoder
+import SDWebImageAVIFCoder
+import SDWebImageSVGCoder
+
+public final class ImageModule: Module {
+  lazy var prefetcher = SDWebImagePrefetcher.shared
+
+  public func definition() -> ModuleDefinition {
+    Name("ExpoImage")
+
+    OnCreate {
+      ImageModule.registerCoders()
+      ImageModule.registerLoaders()
+    }
+
+    View(ImageView.self) {
+      Events(
+        "onLoadStart",
+        "onProgress",
+        "onError",
+        "onLoad"
+      )
+
+      Prop("source") { (view, sources: [ImageSource]?) in
+        view.sources = sources
+      }
+
+      Prop("placeholder") { (view, placeholders: [ImageSource]?) in
+        view.placeholderSources = placeholders ?? []
+      }
+
+      Prop("contentFit") { (view, contentFit: ContentFit?) in
+        view.contentFit = contentFit ?? .cover
+      }
+
+      Prop("placeholderContentFit") { (view, placeholderContentFit: ContentFit?) in
+        view.placeholderContentFit = placeholderContentFit ?? .scaleDown
+      }
+
+      Prop("contentPosition") { (view, contentPosition: ContentPosition?) in
+        view.contentPosition = contentPosition ?? .center
+      }
+
+      Prop("transition") { (view, transition: ImageTransition?) in
+        view.transition = transition
+      }
+
+      Prop("blurRadius") { (view, blurRadius: Double?) in
+        view.blurRadius = blurRadius ?? .zero
+      }
+
+      Prop("tintColor") { (view, tintColor: UIColor?) in
+        view.imageTintColor = tintColor
+      }
+
+      Prop("priority") { (view, priority: ImagePriority?) in
+        view.loadingOptions.remove([.lowPriority, .highPriority])
+
+        if let priority = priority?.toSDWebImageOptions() {
+          view.loadingOptions.insert(priority)
+        }
+      }
+
+      Prop("cachePolicy") { (view, cachePolicy: ImageCachePolicy?) in
+        view.cachePolicy = cachePolicy ?? .disk
+      }
+
+      Prop("enableLiveTextInteraction") { (view, enableLiveTextInteraction: Bool?) in
+        view.enableLiveTextInteraction = enableLiveTextInteraction ?? false
+      }
+
+      Prop("accessible") { (view, accessible: Bool?) in
+        view.sdImageView.isAccessibilityElement = accessible ?? false
+      }
+
+      Prop("accessibilityLabel") { (view, label: String?) in
+        view.sdImageView.accessibilityLabel = label
+      }
+
+      Prop("recyclingKey") { (view, key: String?) in
+        view.recyclingKey = key
+      }
+
+      OnViewDidUpdateProps { view in
+        view.reload()
+      }
+    }
+
+    Function("prefetch") { (urls: [URL]) in
+      SDWebImagePrefetcher.shared.prefetchURLs(urls)
+    }
+
+    AsyncFunction("clearMemoryCache") { () -> Bool in
+      SDImageCache.shared.clearMemory()
+      return true
+    }
+
+    AsyncFunction("clearDiskCache") { (promise: Promise) in
+      SDImageCache.shared.clearDisk {
+        promise.resolve(true)
+      }
+    }
+  }
+
+  static func registerCoders() {
+    if #available(iOS 14.0, *) {
+      // By default Animated WebP is not supported
+      SDImageCodersManager.shared.addCoder(SDImageAWebPCoder.shared)
+    } else {
+      // This coder is much slower, but it's the only one that works in iOS 13
+      SDImageCodersManager.shared.addCoder(SDImageWebPCoder.shared)
+    }
+    SDImageCodersManager.shared.addCoder(SDImageAVIFCoder.shared)
+    SDImageCodersManager.shared.addCoder(SDImageSVGCoder.shared)
+    SDImageCodersManager.shared.addCoder(SDImageHEICCoder.shared)
+  }
+
+  static func registerLoaders() {
+    SDImageLoadersManager.shared.addLoader(BlurhashLoader())
+    SDImageLoadersManager.shared.addLoader(ThumbhashLoader())
+    SDImageLoadersManager.shared.addLoader(PhotoLibraryAssetLoader())
+  }
+}

package/ios/ImagePriority.swift

@@ -0,0 +1,22 @@
+import ExpoModulesCore
+import SDWebImage
+
+enum ImagePriority: String, Enumerable {
+  case low
+  case normal
+  case high
+
+  /**
+   Maps the priority to `SDWebImageOptions` which is a bitmask thus has only low and high priority options.
+   */
+  func toSDWebImageOptions() -> SDWebImageOptions? {
+    switch self {
+    case .low:
+      return .lowPriority
+    case .high:
+      return .highPriority
+    default:
+      return nil
+    }
+  }
+}

package/ios/ImageSource.swift

@@ -0,0 +1,44 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+struct ImageSource: Record {
+  @Field
+  var width: Double = 0.0
+
+  @Field
+  var height: Double = 0.0
+
+  @Field
+  var uri: URL? = nil
+
+  @Field
+  var scale: Double = 1.0
+
+  @Field
+  var headers: [String: String]?
+
+  @Field
+  var cacheKey: String?
+
+  var pixelCount: Double {
+    return width * height * scale * scale
+  }
+
+  var isBlurhash: Bool {
+    return uri?.scheme == "blurhash"
+  }
+
+  var isThumbhash: Bool {
+    return uri?.scheme == "thumbhash"
+  }
+
+  var isPhotoLibraryAsset: Bool {
+    return isPhotoLibraryAssetUrl(uri)
+  }
+
+  var isCachingAllowed: Bool {
+    // TODO: Don't cache other non-network requests (e.g. data URIs, local files)
+    return !isPhotoLibraryAsset
+  }
+}

package/ios/ImageTransition.swift

@@ -0,0 +1,67 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+
+enum ImageTransitionTiming: String, Enumerable {
+  case easeInOut = "ease-in-out"
+  case easeIn = "ease-in"
+  case easeOut = "ease-out"
+  case linear = "linear"
+
+  func toAnimationOption() -> UIView.AnimationOptions {
+    switch self {
+    case .easeInOut:
+      return .curveEaseInOut
+    case .easeIn:
+      return .curveEaseIn
+    case .easeOut:
+      return .curveEaseOut
+    case .linear:
+      return .curveLinear
+    }
+  }
+}
+
+enum ImageTransitionEffect: String, Enumerable {
+  case crossDissolve = "cross-dissolve"
+  case flipFromTop = "flip-from-top"
+  case flipFromRight = "flip-from-right"
+  case flipFromBottom = "flip-from-bottom"
+  case flipFromLeft = "flip-from-left"
+  case curlUp = "curl-up"
+  case curlDown = "curl-down"
+
+  func toAnimationOption() -> UIView.AnimationOptions {
+    switch self {
+    case .crossDissolve:
+      return .transitionCrossDissolve
+    case .flipFromLeft:
+      return .transitionFlipFromLeft
+    case .flipFromRight:
+      return .transitionFlipFromRight
+    case .flipFromTop:
+      return .transitionFlipFromTop
+    case .flipFromBottom:
+      return .transitionFlipFromBottom
+    case .curlUp:
+      return .transitionCurlUp
+    case .curlDown:
+      return .transitionCurlDown
+    }
+  }
+}
+
+struct ImageTransition: Record {
+  @Field
+  var duration: Double = 100
+
+  @Field
+  var timing: ImageTransitionTiming = .easeInOut
+
+  @Field
+  var effect: ImageTransitionEffect = .crossDissolve
+
+  func toAnimationOptions() -> UIView.AnimationOptions {
+    return [timing.toAnimationOption(), effect.toAnimationOption()]
+  }
+}

package/ios/ImageUtils.swift

@@ -0,0 +1,227 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import SDWebImage
+import ExpoModulesCore
+
+func cacheTypeToString(_ cacheType: SDImageCacheType) -> String {
+  switch cacheType {
+  case .none:
+    return "none"
+  case .disk:
+    return "disk"
+  case .memory, .all:
+    // `all` doesn't make much sense, so we treat it as `memory`.
+    return "memory"
+  }
+}
+
+func imageFormatToMediaType(_ format: SDImageFormat) -> String? {
+  switch format {
+  case .undefined:
+    return nil
+  case .JPEG:
+    return "image/jpeg"
+  case .PNG:
+    return "image/png"
+  case .GIF:
+    return "image/gif"
+  case .TIFF:
+    return "image/tiff"
+  case .webP:
+    return "image/webp"
+  case .HEIC:
+    return "image/heic"
+  case .HEIF:
+    return "image/heif"
+  case .PDF:
+    return "application/pdf"
+  case .SVG:
+    return "image/svg+xml"
+  default:
+    // On one hand we could remove this clause and always ensure that we have handled
+    // all supported formats (by erroring compilation otherwise).
+    // On the other hand, we do support overriding SDWebImage version,
+    // so we shouldn't fail to compile on SDWebImage versions with.
+    return nil
+  }
+}
+
+/**
+ Calculates the ideal size that fills in the container size while maintaining the source aspect ratio.
+ */
+func idealSize(contentPixelSize: CGSize, containerSize: CGSize, scale: Double, contentFit: ContentFit) -> CGSize {
+  switch contentFit {
+  case .contain:
+    let aspectRatio = min(containerSize.width / contentPixelSize.width, containerSize.height / contentPixelSize.height)
+    return contentPixelSize * aspectRatio
+  case .cover:
+    let aspectRatio = max(containerSize.width / contentPixelSize.width, containerSize.height / contentPixelSize.height)
+    return contentPixelSize * aspectRatio
+  case .fill:
+    return containerSize
+  case .scaleDown:
+    if containerSize.width < contentPixelSize.width / scale || containerSize.height < contentPixelSize.height / scale {
+      // The container is smaller than the image — scale it down and behave like `contain`
+      let aspectRatio = min(containerSize.width / contentPixelSize.width, containerSize.height / contentPixelSize.height)
+      return contentPixelSize * aspectRatio
+    } else {
+      // The container is bigger than the image — don't scale it and behave like `none`
+      return contentPixelSize / scale
+    }
+  case .none:
+    return contentPixelSize / scale
+  }
+}
+
+/**
+ Returns a bool whether the image should be downscaled to the given size.
+ */
+func shouldDownscale(image: UIImage, toSize size: CGSize, scale: Double) -> Bool {
+  if size.width <= 0 || size.height <= 0 {
+    // View is invisible, so no reason to keep the image in memory.
+    // This already ensures that we won't be diving by zero in ratio calculations.
+    return true
+  }
+  if size.width.isInfinite || size.height.isInfinite {
+    // Keep the image unscaled for infinite sizes.
+    return false
+  }
+  let imageSize = image.size * image.scale
+  return imageSize.width > (size.width * scale) && imageSize.height > (size.height * scale)
+}
+
+/**
+ Resizes the animated image to fit in the given size and scale.
+ */
+func resize(animatedImage image: UIImage, toSize size: CGSize, scale: Double) async -> UIImage {
+  // For animated images, the `images` member is non-nil and represents an array of animation frames.
+  if let images = image.images {
+    // Resize each animation frame separately.
+    let resizedImages = await concurrentMap(images) { image in
+      return resize(image: image, toSize: size, scale: scale)
+    }
+
+    // `animatedImage(with:duration:)` can return `nil`, probably when scales are not the same
+    // so it should never happen in our case, but let's handle it gracefully.
+    if let animatedImage = UIImage.animatedImage(with: resizedImages, duration: image.duration) {
+      return animatedImage
+    }
+  }
+  return resize(image: image, toSize: size, scale: scale)
+}
+
+/**
+ Resizes a still image to fit in the given size and scale.
+ */
+func resize(image: UIImage, toSize size: CGSize, scale: Double) -> UIImage {
+  let format = UIGraphicsImageRendererFormat()
+  format.scale = scale
+
+  return UIGraphicsImageRenderer(size: size, format: format).image { _ in
+    image.draw(in: CGRect(origin: .zero, size: size))
+  }
+}
+
+/**
+ The image source that fits best into the given size, that is the one with the closest number of pixels.
+ May be `nil` if there are no sources available or the size is zero.
+ */
+func getBestSource(from sources: [ImageSource]?, forSize size: CGSize, scale: Double = 1.0) -> ImageSource? {
+  guard let sources = sources, !sources.isEmpty else {
+    return nil
+  }
+  if size.width <= 0 || size.height <= 0 {
+    return nil
+  }
+  if sources.count == 1 {
+    return sources.first
+  }
+  var bestSource: ImageSource?
+  var bestFit = Double.infinity
+  let targetPixelCount = size.width * size.height * scale * scale
+
+  for source in sources {
+    let fit = abs(1 - (source.pixelCount / targetPixelCount))
+
+    if fit < bestFit {
+      bestSource = source
+      bestFit = fit
+    }
+  }
+  return bestSource
+}
+
+/**
+ Creates the cache key filter that returns the specific string.
+ */
+func createCacheKeyFilter(_ cacheKey: String?) -> SDWebImageCacheKeyFilter? {
+  guard let cacheKey = cacheKey else {
+    return nil
+  }
+  return SDWebImageCacheKeyFilter { _ in
+    return cacheKey
+  }
+}
+
+extension CGSize {
+  /**
+   Multiplies a size with a scalar.
+   */
+  static func * (size: CGSize, scalar: Double) -> CGSize {
+    return CGSize(width: size.width * scalar, height: size.height * scalar)
+  }
+
+  /**
+   Divides a size with a scalar.
+   */
+  static func / (size: CGSize, scalar: Double) -> CGSize {
+    return CGSize(width: size.width / scalar, height: size.height / scalar)
+  }
+
+  /**
+   Returns a new CGSize with width and height rounded to an integral value using the specified rounding rule.
+   */
+  func rounded(_ rule: FloatingPointRoundingRule) -> CGSize {
+    return CGSize(width: width.rounded(rule), height: height.rounded(rule))
+  }
+}
+
+func makeNSError(description: String) -> NSError {
+  let userInfo = [NSLocalizedDescriptionKey: description]
+  return NSError(domain: "expo.modules.image", code: 0, userInfo: userInfo)
+}
+
+// MARK: - Async helpers
+// TODO: Add helpers like these to the modules core eventually
+
+/**
+ Asynchronously maps the given sequence (sequentially).
+ */
+func asyncMap<ItemsType: Sequence, ResultType>(
+  _ items: ItemsType,
+  _ transform: (ItemsType.Element) async throws -> ResultType
+) async rethrows -> [ResultType] {
+  var values = [ResultType]()
+
+  for item in items {
+    try await values.append(transform(item))
+  }
+  return values
+}
+
+/**
+ Concurrently maps the given sequence.
+ */
+func concurrentMap<ItemsType: Sequence, ResultType>(
+  _ items: ItemsType,
+  _ transform: @escaping (ItemsType.Element) async throws -> ResultType
+) async rethrows -> [ResultType] {
+  let tasks = items.map { item in
+    Task {
+      try await transform(item)
+    }
+  }
+  return try await asyncMap(tasks) { task in
+    try await task.value
+  }
+}