zkit-ui 2.0.3 → 2.0.5

package/ios/GaleriaView.swift

@@ -0,0 +1,253 @@
+import ExpoModulesCore
+import UIKit
+
+class GaleriaView: ExpoView {
+  private var childImageView: UIImageView?
+  private weak var registeredAnchorImageView: UIImageView?
+  private var registeredGalleryId: String?
+  private var registeredIndex: Int?
+
+  deinit {
+    unregisterCurrentAnchor()
+  }
+
+  override func didMoveToWindow() {
+    super.didMoveToWindow()
+    if window == nil {
+      unregisterCurrentAnchor()
+    } else {
+      registerCurrentAnchorIfNeeded()
+    }
+  }
+
+  func getChildImageView() -> UIImageView? {
+    var reactSubviews: [UIView]? = nil
+    if RCTIsNewArchEnabled() {
+      reactSubviews = self.subviews
+    } else {
+      reactSubviews = self.reactSubviews()
+    }
+
+    guard let reactSubviews = reactSubviews else { return nil }
+
+    for reactSubview in reactSubviews {
+      if let iv = findImageView(in: reactSubview) {
+        childImageView = iv
+        return iv
+      }
+    }
+
+    return nil
+  }
+
+  private func findImageView(in view: UIView) -> UIImageView? {
+    if let imageView = view as? UIImageView { return imageView }
+    for subview in view.subviews {
+      if let imageView = subview as? UIImageView { return imageView }
+      if let nested = findImageView(in: subview) { return nested }
+    }
+    return nil
+  }
+
+  #if !RCT_NEW_ARCH_ENABLED
+    override func insertReactSubview(_ subview: UIView!, at atIndex: Int) {
+      super.insertReactSubview(subview, at: atIndex)
+      setupImageView()
+    }
+  #endif
+
+  #if RCT_NEW_ARCH_ENABLED
+    // https://github.com/nandorojo/galeria/issues/19
+    // Cleanup gesture recognizers from the image view to work with fabric view recycling
+    override func unmountChildComponentView(_ childComponentView: UIView, index: Int) {
+      unregisterCurrentAnchor()
+      childImageView?.removeGaleriaViewerInteraction()
+      childImageView = nil
+      super.unmountChildComponentView(childComponentView, index: index)
+    }
+  #endif
+
+  var theme: Theme = .dark
+  var urls: [String]?
+  var items: [[String: Any]]?
+  var initialIndex: Int?
+  var galleryId: String?
+  var closeIconName: String?
+  var rightNavItemIconName: String?
+  let onPressRightNavItemIcon = EventDispatcher()
+  let onIndexChange = EventDispatcher()
+
+  public func setupImageView() {
+    registerCurrentAnchorIfNeeded()
+    guard let childImage = getChildImageView() else {
+      return
+    }
+
+    if let items = self.items, let initialIndex = self.initialIndex {
+      setupViewerWithItems(childImage, items: items, initialIndex: initialIndex)
+    } else if let urls = self.urls, let initialIndex = self.initialIndex {
+      setupViewerWithUrls(childImage, urls: urls, initialIndex: initialIndex)
+    } else {
+      setupViewerWithSingleImage(childImage)
+    }
+  }
+
+  private func setupViewerWithItems(
+    _ childImage: UIImageView,
+    items: [[String: Any]],
+    initialIndex: Int
+  ) {
+    let configuration = buildViewerConfiguration()
+
+    let imageItems: [GaleriaMediaItem] = items.compactMap { item in
+        guard let type = item["type"] as? String else { return nil }
+
+        if type == "video", let urlStr = item["url"] as? String, let url = URL(string: urlStr) {
+            var posterUrl: URL? = nil
+            if let posterStr = item["poster"] as? String {
+                posterUrl = URL(string: posterStr)
+            }
+            return GaleriaMediaItem.video(url: url, poster: posterUrl)
+        } else if type == "image", let urlStr = item["url"] as? String {
+             if urlStr.hasPrefix("http://") || urlStr.hasPrefix("https://") || urlStr.hasPrefix("file://") {
+                if let url = URL(string: urlStr) {
+                    return GaleriaMediaItem.imageURL(url, placeholder: nil)
+                }
+             } else {
+                return GaleriaMediaItem.imageURL(URL(fileURLWithPath: urlStr), placeholder: nil)
+             }
+        }
+        return nil
+    }
+
+    let datasource = GaleriaArrayDataSource(items: imageItems)
+    childImage.setupGaleriaViewer(
+      dataSource: datasource,
+      initialIndex: initialIndex,
+      configuration: configuration,
+      galleryId: galleryId)
+  }
+
+
+  private func setupViewerWithUrls(
+    _ childImage: UIImageView,
+    urls: [String],
+    initialIndex: Int
+  ) {
+    let configuration = buildViewerConfiguration()
+
+    let urlObjects: [URL] = urls.compactMap { string in
+      if string.hasPrefix("http://") || string.hasPrefix("https://") || string.hasPrefix("file://") {
+        return URL(string: string)
+      }
+      return URL(fileURLWithPath: string)
+    }
+
+    childImage.setupGaleriaViewer(
+      urls: urlObjects,
+      initialIndex: initialIndex,
+      configuration: configuration,
+      galleryId: galleryId)
+  }
+
+  private func setupViewerWithSingleImage(_ childImage: UIImageView) {
+    guard let img = childImage.image else {
+      print("Missing image in childImage: \(childImage)")
+      return
+    }
+    let configuration = buildViewerConfiguration()
+
+    childImage.setupGaleriaViewer(images: [img], configuration: configuration, galleryId: galleryId)
+  }
+
+  private func buildViewerConfiguration() -> GaleriaViewerConfiguration {
+    var configuration = GaleriaViewerConfiguration(theme: theme.toViewerTheme())
+    let iconColor = theme.iconColor()
+
+    if let closeIconName = closeIconName,
+      let closeIconImage = UIImage(systemName: closeIconName)?.withTintColor(
+        iconColor, renderingMode: .alwaysOriginal)
+    {
+      configuration.closeIcon = closeIconImage
+    }
+
+    if let rightIconName = rightNavItemIconName,
+      let rightIconImage = UIImage(systemName: rightIconName)?.withTintColor(
+        iconColor, renderingMode: .alwaysOriginal)
+    {
+      configuration.rightBarButton = .icon(
+        rightIconImage,
+        onTap: { index in
+          self.onPressRightNavItemIcon(["index": index])
+        })
+    }
+
+    configuration.onIndexChange = { [weak self] index in
+      self?.onIndexChange(["currentIndex": index])
+    }
+    return configuration
+  }
+
+  private func registerCurrentAnchorIfNeeded() {
+    guard
+      window != nil,
+      let galleryId,
+      let initialIndex,
+      let childImage = getChildImageView()
+    else {
+      unregisterCurrentAnchor()
+      return
+    }
+
+    if
+      let registeredAnchorImageView,
+      (registeredAnchorImageView !== childImage
+        || registeredGalleryId != galleryId
+        || registeredIndex != initialIndex)
+    {
+      unregisterCurrentAnchor()
+    }
+
+    GaleriaSourceViewRegistry.shared.register(
+      childImage,
+      galleryId: galleryId,
+      index: initialIndex)
+    registeredAnchorImageView = childImage
+    registeredGalleryId = galleryId
+    registeredIndex = initialIndex
+  }
+
+  private func unregisterCurrentAnchor() {
+    if let registeredAnchorImageView = registeredAnchorImageView {
+      GaleriaSourceViewRegistry.shared.unregister(
+        registeredAnchorImageView,
+        galleryId: registeredGalleryId,
+        index: registeredIndex)
+    }
+    registeredAnchorImageView = nil
+    registeredGalleryId = nil
+    registeredIndex = nil
+  }
+}
+
+enum Theme: String, Enumerable {
+  case dark
+  case light
+
+  func toViewerTheme() -> GaleriaViewerTheme {
+    switch self {
+    case .dark:
+      return .dark
+    case .light:
+      return .light
+    }
+  }
+  func iconColor() -> UIColor {
+    switch self {
+    case .dark:
+      return .white
+    case .light:
+      return .black
+    }
+  }
+}

package/ios/GalleryViewer/GaleriaImageLoader.swift

@@ -0,0 +1,73 @@
+import Foundation
+import UIKit
+#if canImport(SDWebImage)
+import SDWebImage
+#endif
+
+public protocol GaleriaImageLoading {
+    func loadImage(
+        _ url: URL,
+        placeholder: UIImage?,
+        imageView: UIImageView,
+        completion: @escaping (_ image: UIImage?) -> Void
+    )
+}
+
+public struct GaleriaURLSessionImageLoader: GaleriaImageLoading {
+    public init() {}
+
+    public func loadImage(
+        _ url: URL,
+        placeholder: UIImage?,
+        imageView: UIImageView,
+        completion: @escaping (UIImage?) -> Void
+    ) {
+        if let placeholder = placeholder {
+            imageView.image = placeholder
+        }
+
+        DispatchQueue.global(qos: .background).async {
+            guard let data = try? Data(contentsOf: url), let image = UIImage(data: data) else {
+                completion(nil)
+                return
+            }
+
+            DispatchQueue.main.async {
+                imageView.image = image
+                completion(image)
+            }
+        }
+    }
+}
+
+#if canImport(SDWebImage)
+struct GaleriaSDWebImageLoader: GaleriaImageLoading {
+    func loadImage(
+        _ url: URL,
+        placeholder: UIImage?,
+        imageView: UIImageView,
+        completion: @escaping (UIImage?) -> Void
+    ) {
+        imageView.sd_setImage(
+            with: url,
+            placeholderImage: placeholder,
+            options: [],
+            progress: nil
+        ) { image, _, _, _ in
+            DispatchQueue.main.async {
+                completion(image)
+            }
+        }
+    }
+}
+#endif
+
+public enum GaleriaImageLoaderFactory {
+    public static func makeDefault() -> GaleriaImageLoading {
+        #if canImport(SDWebImage)
+        return GaleriaSDWebImageLoader()
+        #else
+        return GaleriaURLSessionImageLoader()
+        #endif
+    }
+}

package/ios/GalleryViewer/GaleriaImageViewInteraction.swift

@@ -0,0 +1,245 @@
+import ObjectiveC
+import UIKit
+
+extension UIImageView {
+    private struct GaleriaAnchorRegistration {
+        let galleryId: String
+        let index: Int
+    }
+
+    private final class GaleriaTapGestureRecognizer: UITapGestureRecognizer {
+        weak var fromViewController: UIViewController?
+        var dataSource: GaleriaDataSource?
+        var imageLoader: GaleriaImageLoading?
+        var initialIndex = 0
+        var galleryId: String?
+        var configuration = GaleriaViewerConfiguration()
+    }
+
+    private static var anchorRegistrationKey: UInt8 = 0
+    private static var gestureRecognizerKey: UInt8 = 0
+
+    private var topMostHostViewController: UIViewController? {
+        let keyWindow: UIWindow? = {
+            if #available(iOS 13.0, *) {
+                let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+                let activeScene = scenes.first(where: { $0.activationState == .foregroundActive }) ?? scenes.first
+                return activeScene?.windows.first(where: { $0.isKeyWindow }) ?? activeScene?.windows.first
+            } else {
+                return UIApplication.shared.windows.first(where: { $0.isKeyWindow }) ?? UIApplication.shared.windows.first
+            }
+        }()
+        guard let rootViewController = keyWindow?.rootViewController else { return nil }
+        return rootViewController.presentedViewController ?? rootViewController
+    }
+
+    public func setupGaleriaViewer(
+        configuration: GaleriaViewerConfiguration = GaleriaViewerConfiguration(),
+        from viewController: UIViewController? = nil,
+        imageLoader: GaleriaImageLoading? = nil,
+        galleryId: String? = nil
+    ) {
+        configureGaleriaViewer(
+            dataSource: GaleriaArrayDataSource(items: [.image(image)]),
+            initialIndex: 0,
+            configuration: configuration,
+            from: viewController,
+            imageLoader: imageLoader,
+            galleryId: galleryId
+        )
+    }
+
+    public func setupGaleriaViewer(
+        url: URL,
+        initialIndex: Int = 0,
+        placeholder: UIImage? = nil,
+        configuration: GaleriaViewerConfiguration = GaleriaViewerConfiguration(),
+        from viewController: UIViewController? = nil,
+        imageLoader: GaleriaImageLoading? = nil,
+        galleryId: String? = nil
+    ) {
+        configureGaleriaViewer(
+            dataSource: GaleriaArrayDataSource(items: [.imageURL(url, placeholder: placeholder)]),
+            initialIndex: initialIndex,
+            configuration: configuration,
+            from: viewController,
+            imageLoader: imageLoader,
+            galleryId: galleryId
+        )
+    }
+
+    public func setupGaleriaViewer(
+        images: [UIImage],
+        initialIndex: Int = 0,
+        configuration: GaleriaViewerConfiguration = GaleriaViewerConfiguration(),
+        from viewController: UIViewController? = nil,
+        imageLoader: GaleriaImageLoading? = nil,
+        galleryId: String? = nil
+    ) {
+        let items = images.map { GaleriaMediaItem.image($0) }
+        configureGaleriaViewer(
+            dataSource: GaleriaArrayDataSource(items: items),
+            initialIndex: initialIndex,
+            configuration: configuration,
+            from: viewController,
+            imageLoader: imageLoader,
+            galleryId: galleryId
+        )
+    }
+
+    public func setupGaleriaViewer(
+        urls: [URL],
+        initialIndex: Int = 0,
+        placeholder: UIImage? = nil,
+        configuration: GaleriaViewerConfiguration = GaleriaViewerConfiguration(),
+        from viewController: UIViewController? = nil,
+        imageLoader: GaleriaImageLoading? = nil,
+        galleryId: String? = nil
+    ) {
+        let items = urls.map { GaleriaMediaItem.imageURL($0, placeholder: placeholder) }
+        configureGaleriaViewer(
+            dataSource: GaleriaArrayDataSource(items: items),
+            initialIndex: initialIndex,
+            configuration: configuration,
+            from: viewController,
+            imageLoader: imageLoader,
+            galleryId: galleryId
+        )
+    }
+
+    public func setupGaleriaViewer(
+        dataSource: GaleriaDataSource,
+        initialIndex: Int = 0,
+        configuration: GaleriaViewerConfiguration = GaleriaViewerConfiguration(),
+        from viewController: UIViewController? = nil,
+        imageLoader: GaleriaImageLoading? = nil,
+        galleryId: String? = nil
+    ) {
+        configureGaleriaViewer(
+            dataSource: dataSource,
+            initialIndex: initialIndex,
+            configuration: configuration,
+            from: viewController,
+            imageLoader: imageLoader,
+            galleryId: galleryId
+        )
+    }
+
+    func removeGaleriaViewerInteraction() {
+        if let recognizer = galeriaTapGestureRecognizer {
+            removeGestureRecognizer(recognizer)
+        }
+        galeriaTapGestureRecognizer = nil
+
+        if let registration = galeriaAnchorRegistration {
+            GaleriaSourceViewRegistry.shared.unregister(
+                self,
+                galleryId: registration.galleryId,
+                index: registration.index
+            )
+        }
+        galeriaAnchorRegistration = nil
+    }
+
+    private func configureGaleriaViewer(
+        dataSource: GaleriaDataSource?,
+        initialIndex: Int,
+        configuration: GaleriaViewerConfiguration,
+        from viewController: UIViewController?,
+        imageLoader: GaleriaImageLoading?,
+        galleryId: String?
+    ) {
+        let recognizer = galeriaTapGestureRecognizer ?? {
+            let recognizer = GaleriaTapGestureRecognizer(target: self, action: #selector(showGaleriaViewer(_:)))
+            recognizer.numberOfTouchesRequired = 1
+            recognizer.numberOfTapsRequired = 1
+            galeriaTapGestureRecognizer = recognizer
+            return recognizer
+        }()
+
+        isUserInteractionEnabled = true
+        clipsToBounds = true
+
+        recognizer.dataSource = dataSource
+        recognizer.imageLoader = imageLoader
+        recognizer.initialIndex = initialIndex
+        recognizer.galleryId = galleryId
+        recognizer.configuration = configuration
+        recognizer.fromViewController = viewController
+
+        if recognizer.view !== self {
+            addGestureRecognizer(recognizer)
+        }
+
+        updateGaleriaAnchorRegistration(galleryId: galleryId, index: initialIndex)
+    }
+
+    private var galeriaTapGestureRecognizer: GaleriaTapGestureRecognizer? {
+        get {
+            objc_getAssociatedObject(self, &Self.gestureRecognizerKey) as? GaleriaTapGestureRecognizer
+        }
+        set {
+            objc_setAssociatedObject(
+                self,
+                &Self.gestureRecognizerKey,
+                newValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+
+    private var galeriaAnchorRegistration: GaleriaAnchorRegistration? {
+        get {
+            objc_getAssociatedObject(self, &Self.anchorRegistrationKey) as? GaleriaAnchorRegistration
+        }
+        set {
+            objc_setAssociatedObject(
+                self,
+                &Self.anchorRegistrationKey,
+                newValue,
+                .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+            )
+        }
+    }
+
+    @objc
+    private func showGaleriaViewer(_ recognizer: GaleriaTapGestureRecognizer) {
+        guard let sourceView = recognizer.view as? UIImageView else { return }
+        let resolvedImageLoader = recognizer.imageLoader ?? GaleriaImageLoaderFactory.makeDefault()
+        let viewerController = GaleriaViewerController(
+            sourceView: sourceView,
+            dataSource: recognizer.dataSource,
+            imageLoader: resolvedImageLoader,
+            configuration: recognizer.configuration,
+            initialIndex: recognizer.initialIndex,
+            galleryId: recognizer.galleryId
+        )
+
+        let rootViewController = recognizer.fromViewController ?? topMostHostViewController
+        let presenter = rootViewController.flatMap(topMostPresentedController(from:))
+        presenter?.present(viewerController, animated: false)
+    }
+
+    private func topMostPresentedController(from rootViewController: UIViewController) -> UIViewController {
+        var controller = rootViewController
+        while let presented = controller.presentedViewController {
+            controller = presented
+        }
+        return controller
+    }
+
+    private func updateGaleriaAnchorRegistration(galleryId: String?, index: Int) {
+        if let existing = galeriaAnchorRegistration {
+            GaleriaSourceViewRegistry.shared.unregister(
+                self,
+                galleryId: existing.galleryId,
+                index: existing.index
+            )
+            galeriaAnchorRegistration = nil
+        }
+
+        guard let galleryId = galleryId, galleryId.isEmpty == false else { return }
+        GaleriaSourceViewRegistry.shared.register(self, galleryId: galleryId, index: index)
+        galeriaAnchorRegistration = GaleriaAnchorRegistration(galleryId: galleryId, index: index)
+    }
+}