Minor improvements

• Updated the PhotoLibrary to support rendering animated thumbnails of files
• Replaced the `closureThumbnail` with `asyncSource` (which is more reusable)
• Reduced the size of the thumbnails generated for the All Media grid and quotes (the `small` size is already bigger than what we are rendering so we should use that for performance)
• Added the `gif` label to animated thumbnails for the PhotoLibrary picker for consistency

Author: mpretty-cyro

Session/Conversations/Message Cells/Content Views/QuoteView.swift

@@ -131,7 +131,7 @@ final class QuoteView: UIView {
             }
 
             // Generate the thumbnail if needed
-            imageView.loadThumbnail(size: .medium, attachment: attachment, using: dependencies) { [weak imageView] success in
+            imageView.loadThumbnail(size: .small, attachment: attachment, using: dependencies) { [weak imageView] success in
                 guard success else { return }
 
                 imageView?.contentMode = .scaleAspectFill

Session/Conversations/Message Cells/Content Views/SwiftUI/QuoteView_SwiftUI.swift

@@ -83,7 +83,7 @@ struct QuoteView_SwiftUI: View {
 
                     SessionAsyncImage(
                         attachment: attachment,
-                        thumbnailSize: .medium,
+                        thumbnailSize: .small,
                         using: dependencies
                     ) { image in
                         image

Session/Media Viewing & Editing/MediaTileViewController.swift

@@ -893,7 +893,7 @@ class GalleryGridCellItem: PhotoGridItem {
     var source: ImageDataManager.DataSource {
         ImageDataManager.DataSource.thumbnailFrom(
             attachment: galleryItem.attachment,
-            size: .medium,
+            size: .small,
             using: dependencies
         ) ?? .image("", nil)
     }

Session/Media Viewing & Editing/PhotoLibrary.swift

@@ -52,13 +52,15 @@ class PhotoPickerAssetItem: PhotoGridItem {
             return .video
         }
 
-        // TODO show GIF badge?
+        if asset.utType?.isAnimated == true {
+            return .animated
+        }
 
         return  .photo
     }
 
     var source: ImageDataManager.DataSource {
-        return .closureThumbnail(self.asset.localIdentifier, size) { [photoCollectionContents, asset, size, pixelDimension] in
+        return .asyncSource(self.asset.localIdentifier) { [photoCollectionContents, asset, size, pixelDimension] in
             await photoCollectionContents.requestThumbnail(
                 for: asset,
                 size: size,
@@ -148,44 +150,70 @@ class PhotoCollectionContents {
 
     // MARK: ImageManager
 
-    func requestThumbnail(for asset: PHAsset, size: ImageDataManager.ThumbnailSize, thumbnailSize: CGSize) async -> UIImage? {
+    func requestThumbnail(for asset: PHAsset, size: ImageDataManager.ThumbnailSize, thumbnailSize: CGSize) async -> ImageDataManager.DataSource? {
         var hasResumed: Bool = false
 
-        return await withCheckedContinuation { [imageManager] continuation in
-            let options = PHImageRequestOptions()
-            
-            switch size {
-                case .small: options.deliveryMode = .opportunistic
-                case .medium, .large: options.deliveryMode = .highQualityFormat
-            }
-            
-            imageManager.requestImage(
-                for: asset,
-                targetSize: thumbnailSize,
-                contentMode: .aspectFill,
-                options: options
-            ) { image, info in
-                guard !hasResumed else { return }
-                guard
-                    info?[PHImageErrorKey] == nil,
-                    (info?[PHImageCancelledKey] as? Bool) != true
-                else {
-                    hasResumed = true
-                    return continuation.resume(returning: nil)
+        /// The `requestImage` function will always return a static thumbnail so if it's an animated image then we need custom
+        /// handling (the default PhotoKit resizing can't resize animated images so we need to return the original file)
+        switch asset.utType?.isAnimated {
+            case .some(true):
+                return await withCheckedContinuation { [imageManager] continuation in
+                    let options = PHImageRequestOptions()
+                    options.deliveryMode = .highQualityFormat
+                    options.isNetworkAccessAllowed = true
+                    
+                    imageManager.requestImageDataAndOrientation(for: asset, options: options) { data, uti, orientation, info in
+                        guard !hasResumed else { return }
+                        
+                        guard let data = data, info?[PHImageErrorKey] == nil else {
+                            hasResumed = true
+                            continuation.resume(returning: nil)
+                            return
+                        }
+                        
+                        // Successfully fetched the data, resume with the animated result
+                        hasResumed = true
+                        continuation.resume(returning: .data(asset.localIdentifier, data))
+                    }
                 }
 
-                switch size {
-                    case .small: break  // We want the first image, whether it is degraded or not
-                    case .medium, .large:
-                        // For medium and large thumbnails we want the full image so ignore any
-                        // degraded images
-                        guard (info?[PHImageResultIsDegradedKey] as? Bool) != true else { return }
-
+            default:
+                return await withCheckedContinuation { [imageManager] continuation in
+                    let options = PHImageRequestOptions()
+                    
+                    switch size {
+                        case .small: options.deliveryMode = .opportunistic
+                        case .medium, .large: options.deliveryMode = .highQualityFormat
+                    }
+                    
+                    imageManager.requestImage(
+                        for: asset,
+                        targetSize: thumbnailSize,
+                        contentMode: .aspectFill,
+                        options: options
+                    ) { image, info in
+                        guard !hasResumed else { return }
+                        guard
+                            info?[PHImageErrorKey] == nil,
+                            (info?[PHImageCancelledKey] as? Bool) != true
+                        else {
+                            hasResumed = true
+                            return continuation.resume(returning: nil)
+                        }
+                        
+                        switch size {
+                            case .small: break  // We want the first image, whether it is degraded or not
+                            case .medium, .large:
+                                // For medium and large thumbnails we want the full image so ignore any
+                                // degraded images
+                                guard (info?[PHImageResultIsDegradedKey] as? Bool) != true else { return }
+                                
+                        }
+                        
+                        continuation.resume(returning: .image("\(asset.localIdentifier)-\(size)", image))
+                        hasResumed = true
+                    }
                 }
-                
-                continuation.resume(returning: image)
-                hasResumed = true
-            }
         }
     }
 
@@ -482,3 +510,10 @@ class PhotoLibrary: NSObject, PHPhotoLibraryChangeObserver {
         return collections
     }
 }
+
+private extension PHAsset {
+    var utType: UTType? {
+        return (value(forKey: "uniformTypeIdentifier") as? String) // stringlint:ignore
+            .map { UTType($0) }
+    }
+}

SessionUIKit/Types/ImageDataManager.swift

@@ -206,27 +206,6 @@ public actor ImageDataManager: ImageDataManagerType {
                     type: .staticImage(decodedImage)
                 )
 
-            case .closureThumbnail(_, _, let imageRetrier):
-                guard let image: UIImage = await imageRetrier() else { return nil }
-                guard
-                    let cgImage: CGImage = image.cgImage,
-                    let decodingContext: CGContext = createDecodingContext(
-                        width: cgImage.width,
-                        height: cgImage.height
-                    ),
-                    let decodedImage: UIImage = predecode(cgImage: cgImage, using: decodingContext)
-                else {
-                    return ProcessedImageData(
-                        type: .staticImage(image)
-                    )
-                }
-                
-                /// Since there is likely custom (external) logic used to retrieve this thumbnail we don't save it to disk as there
-                /// is no way to know if it _should_ change between generations/launches or not
-                return ProcessedImageData(
-                    type: .staticImage(decodedImage)
-                )
-                
             /// Custom handle `placeholderIcon` generation
             case .placeholderIcon(let seed, let text, let size):
                 let image: UIImage = PlaceholderIcon.generate(seed: seed, text: text, size: size)
@@ -248,6 +227,11 @@ public actor ImageDataManager: ImageDataManagerType {
                     type: .staticImage(decodedImage)
                 )
 
+            case .asyncSource(_, let sourceRetriever):
+                guard let source: DataSource = await sourceRetriever() else { return nil }
+                
+                return await processSource(source)
+                
             default: break
         }
 
@@ -576,8 +560,8 @@ public extension ImageDataManager {
         case image(String, UIImage?)
         case videoUrl(URL, String, String?, ThumbnailManager)
         case urlThumbnail(URL, ImageDataManager.ThumbnailSize, ThumbnailManager)
-        case closureThumbnail(String, ImageDataManager.ThumbnailSize, @Sendable () async -> UIImage?)
         case placeholderIcon(seed: String, text: String, size: CGFloat)
+        case asyncSource(String, @Sendable () async -> DataSource?)
 
         public var identifier: String {
             switch self {
@@ -588,16 +572,16 @@ public extension ImageDataManager {
                 case .urlThumbnail(let url, let size, _):
                     return "\(url.absoluteString)-\(size)"
 
-                case .closureThumbnail(let identifier, let size, _):
-                    return "\(identifier)-\(size)"
-                
                 case .placeholderIcon(let seed, let text, let size):
                     let content: (intSeed: Int, initials: String) = PlaceholderIcon.content(
                         seed: seed,
                         text: text
                     )
 
                     return "\(seed)-\(content.initials)-\(Int(floor(size)))"
+                
+                /// We will use the identifier from the loaded source for caching purposes
+                case .asyncSource(let identifier, _): return identifier
             }
         }
 
@@ -608,8 +592,8 @@ public extension ImageDataManager {
                 case .image(_, let image): return image?.pngData()
                 case .videoUrl: return nil
                 case .urlThumbnail: return nil
-                case .closureThumbnail: return nil
                 case .placeholderIcon: return nil
+                case .asyncSource: return nil
             }
         }
 
@@ -635,7 +619,7 @@ public extension ImageDataManager {
                 case .urlThumbnail(let url, _, _): return CGImageSourceCreateWithURL(url as CFURL, finalOptions)
 
                 // These cases have special handling which doesn't use `createImageSource`
-                case .image, .videoUrl, .closureThumbnail, .placeholderIcon: return nil
+                case .image, .videoUrl, .placeholderIcon, .asyncSource: return nil
             }
         }
 
@@ -665,19 +649,16 @@ public extension ImageDataManager {
                         lhsSize == rhsSize
                     )
 
-                case (.closureThumbnail(let lhsIdentifier, let lhsSize, _), .closureThumbnail(let rhsIdentifier, let rhsSize, _)):
-                    return (
-                        lhsIdentifier == rhsIdentifier &&
-                        lhsSize == rhsSize
-                    )
-                    
                 case (.placeholderIcon(let lhsSeed, let lhsText, let lhsSize), .placeholderIcon(let rhsSeed, let rhsText, let rhsSize)):
                     return (
                         lhsSeed == rhsSeed &&
                         lhsText == rhsText &&
                         lhsSize == rhsSize
                     )
 
+                case (.asyncSource(let lhsIdentifier, _), .asyncSource(let rhsIdentifier, _)):
+                    return (lhsIdentifier == rhsIdentifier)
+                    
                 default: return false
             }
         }
@@ -702,14 +683,13 @@ public extension ImageDataManager {
                     url.hash(into: &hasher)
                     size.hash(into: &hasher)
 
-                case .closureThumbnail(let identifier, let size, _):
-                    identifier.hash(into: &hasher)
-                    size.hash(into: &hasher)
-                    
                 case .placeholderIcon(let seed, let text, let size):
                     seed.hash(into: &hasher)
                     text.hash(into: &hasher)
                     size.hash(into: &hasher)
+                    
+                case .asyncSource(let identifier, _):
+                    identifier.hash(into: &hasher)
             }
         }
     }
@@ -830,13 +810,13 @@ public extension ImageDataManager.DataSource {
 
                 return image.size
 
-            case .urlThumbnail(_, let size, _), .closureThumbnail(_, let size, _):
+            case .urlThumbnail(_, let size, _):
                 let dimension: CGFloat = size.pixelDimension()
                 return CGSize(width: dimension, height: dimension)
 
             case .placeholderIcon(_, _, let size): return CGSize(width: size, height: size)
 
-            case .url, .data, .videoUrl: break
+            case .url, .data, .videoUrl, .asyncSource: break
         }
 
         /// Since we don't have a direct size, try to extract it from the data