Unified CDN & Media Loading Architecture (v5) (#1399)

* Replace old ImageCDN/FileCDN/ImageLoading with unified CDN/ImageLoader/VideoLoader

Remove old protocols duplicated from StreamChatUI:
- ImageCDN, StreamImageCDN, FileCDN, DefaultFileCDN
- ImageLoading, NukeImageLoader, VideoPreviewLoader

Replace with unified types from StreamChatCommonUI:
- Utils.imageLoader now uses ImageLoader (StreamImageLoader)
- Utils.videoLoader now uses VideoLoader (StreamVideoLoader)
- CDN from StreamChat handles URL signing for files/images
- Update StreamAsyncImage, LazyImageExtensions, and Utils

* Update view models and views to use new CDN/loader APIs

- FileAttachmentPreview and MediaViewer use CDN.fileRequest instead of FileCDN
- MediaAttachment uses ImageLoader and VideoLoader directly
- MessageComposerViewModel uses simplified ImageLoader API
- MoreChannelActionsViewModel drops imageCDN dependency

* Update test mocks and tests for new loader protocols

- Replace ImageLoader_Mock to conform to ImageLoader
- Replace VideoPreviewLoader_Mock with VideoLoader_Mock
- Update test setup to use videoLoader instead of videoPreviewLoader
- Remove ImageCDN_Tests (replaced by StreamCDN_Tests in stream-chat-swift)
- Update VideoPreviewLoader_Tests for new VideoLoader protocol

* Use local stream-chat-swift dependency for development

Point Package.swift and xcodeproj to local ../stream-chat-swift path
for development and testing of the unified CDN refactoring.

* Add NukeImageDownloader and update Utils for ImageDownloading protocol

Provide NukeImageDownloader as the ImageDownloading backend for SwiftUI,
keeping Nuke vendored in this repo while sharing loader logic via CommonUI.
Update Utils to pass NukeImageDownloader to StreamImageLoader.

* Apply CDN transformations in LazyImage extensions

Restore CDN URL transformation (headers, signing, caching key) in the
LazyImage convenience initializers. The CDN completion is captured
synchronously -- for StreamCDN (which completes inline) the full
CDNRequest is used; async CDNs fall back to the raw URL gracefully.

* Add StreamLazyImage wrappers with CDN support

Replace direct LazyImage usage with StreamLazyImage and
StreamLazyContentImage wrappers that resolve CDN transformations
asynchronously via @injected dependencies before passing the
request to Nuke's LazyImage.

* Rename NukeImageDownloader and NukeImageProcessor to Stream prefix

Rename to StreamImageDownloader and StreamImageProcessor to decouple
public API naming from the Nuke dependency.

* Unify StreamAsyncImage as the single image-loading view

Merge StreamLazyContentImage, StreamLazyImage, and StreamAsyncImage
into a single StreamAsyncImage view that handles all image loading.

- CDN transformations resolved async via @injected dependencies
- StreamAsyncImageResult carries UIImage, isAnimated flag, and raw
  animated data for GIF rendering without exposing Nuke types
- Nuke coupling isolated to a single private method (loadWithNuke)
  for easy replacement when removing the Nuke dependency
- Delete LazyImageExtensions.swift (no longer needed)
- Update all call sites: avatars, link previews, giphy attachments
- AnimatedGifView now takes raw Data instead of Nuke ImageContainer

* Fix tests

* Remove maxAttachmentSize from CDNStorage protocol

* Introduce options parameters to the CDNStorage and CDNRequester

* Add remote dependency

* Fix CGSize

* Re-record snapshot for date overlay test on iOS 26.2

* Re-record voice recording snapshot tests for iOS 26.2

* Fix flaky date overlay snapshot test by using same-day timestamps

* Fix swiftformat

* Fix attachment downloads not using CDN requester for URL signing and custom headers

* Adopt unified MediaLoader protocol replacing separate ImageLoader and VideoLoader

- Replace imageLoader + videoLoader with single mediaLoader in Utils
- Update all views and view models to use utils.mediaLoader
- Rename loadPreview to loadVideoPreview for clarity
- Update test mocks and tests for MediaLoader conformance
- Update Package.resolved to latest LLC commit

* Adopt MediaLoader wrapper result types and async videoAsset

- Update call sites to use MediaLoaderImage, MediaLoaderVideoPreview
- Update all test mocks to conform to new MediaLoader signatures
- Update SPM dependency to latest LLC commit

* Access cdnRequester through config instead of ChatClient

Aligns with the removal of cdnRequester/cdnStorage from ChatClient.
All SwiftUI call sites now use chatClient.config.cdnRequester.

* Minor cleanups

* Use commit instead of branch

* Use better task identity in StreamAsyncImage

* Fix type mismatch in VideoPreviewLoader tests

Change receivedImage (UIImage?) to receivedPreview (MediaLoaderVideoPreview?)
to match the actual return type of result.get() from loadVideoPreview.

* Address PR review comments

- Merge ImageLoader_Mock and VideoLoader_Mock into a single
  MediaLoader_Mock, consolidating all tracking properties
- Extract Nuke-specific image loading logic from StreamAsyncImage
  into NukeImageLoader internal helper
- Update all test references to use MediaLoader_Mock

* Make sure cache is always used first

* Make initial phase success in StreamAsyncImage in case the image is available in cache

* Remove Image Processor from SwiftUI since it is not used now

* Fix MediaLoader tests naming

* Fix swiftformat

* Remove throwaway AVPlayer in StreamVideoPlayer

The code was creating and starting an AVPlayer before asking
avPlayerProvider for another player, doubling setup/network
work and briefly swapping the active player mid-playback.
Now only the provider-produced player is used.

* Pass CDN headers to AVPlayerProvider for authenticated playback

Add headers parameter to AVPlayerProvider.player(for:headers:completion:)
so CDN authentication headers from cdnRequester.fileRequest() are
propagated to the player. DefaultAVPlayerProvider uses AVURLAsset with
the headers when available. A default extension preserves backwards
compatibility for existing conformers.

* Add unit tests for NukeImageLoader

Cover the key paths: cachedResult returns nil when no key is stored,
loadImage calls CDN requester with correct URL, onCacheMiss fires on
cache miss, cache hit after CDN transform skips onCacheMiss, and
cachingKeyMap persists across load + cachedResult calls.

* Add unit tests for StreamImageDownloader

Verify error handling for invalid URLs, and that all
ImageDownloadingOptions combinations (headers, cachingKey,
resize, zero resize) are accepted without crash.

* Add fallback branch tests for maxAttachmentSize

Cover the cases where appSettings is nil, server limit is zero,
and server limit is negative — all should return the fallbackSize.

* Add loadImage and loadImages tests for StreamMediaLoader

Cover loadImage success, nil URL error, error propagation from
downloader, loadImages returning correct count, and loadImages
using placeholders on failure.

* Unify video loading via MediaLoader and simplify AVPlayerProvider

Replace manual CDN + AVPlayerProvider flow in StreamVideoPlayer with
MediaLoader.loadVideoAsset(). Simplify AVPlayerProvider to accept
MediaLoaderVideoAsset instead of raw URL + headers. Rename videoAsset
to loadVideoAsset for consistency with other MediaLoader methods.

* Make media loader mock the only mock

* Make StreamImageDownloader final Sendable

* Fix swiftformat

* Update LLC dependency to latest commit

* Rename LazyImageExtensions_Tests.swift to StreamAsyncImage_Tests.swift

Align file name with the test class StreamAsyncImage_Tests it contains.
Also rename test_mediaAttachment_generateThumbnail_callsImageLoader to
reference MediaLoader instead of the removed ImageLoader.

* Fix StreamAsyncImage doc comment referencing non-existent ImageLoader

Update the doc comment to reference MediaLoader and CDNRequester which
are the actual protocols used by this view.

* Update LLC commit

* Use attachment-based video preview loading

Update MediaAttachment and tests to use the attachment-based
loadVideoPreview(with:) instead of the removed URL variant,
enabling thumbnail URL optimization for remote video previews.

* Update LLC dependency and add loadVideoAsset to test conformers

Update to LLC commit that removes the default loadVideoAsset
implementation from MediaLoader, requiring all conformers to
provide explicit implementations.

* Use Utils.cdnRequester instead of ChatClientConfig

Move CDN requester access from chatClient.config.cdnRequester to
utils.cdnRequester, matching the UIKit pattern where it lives in
Components. The download attachment flow now resolves CDN URLs at the
UI layer before calling the core download function.

* Fix cdnrequester tests

* Remove unecessary stream image downloader tests

* Add NukeImageLoader_Tests to project file

* Minor fixes

* Minor review fixes

* Fix load preview mocks

* Update LLC dependency

* Remove unecessary test

* Fix media viewer tests

* [CI] Print verbose logs on old xcode job

* Revert "[CI] Print verbose logs on old xcode job"

This reverts commit 6ee5138.

* Bump Xcode version for old Xcode job

* Revert "Bump Xcode version for old Xcode job"

This reverts commit 286c240.

* Update dependency to develop

* Update dependency again

* [CI] Snapshots (#1420)

Co-authored-by: Stream Bot <ci@getstream.io>

---------

Co-authored-by: Alexey Alter-Pesotskiy <alex@testableapple.com>
Co-authored-by: Stream SDK Bot <60655709+Stream-SDK-Bot@users.noreply.github.com>
Co-authored-by: Stream Bot <ci@getstream.io>

Author: 4 people

CHANGELOG.md

@@ -15,6 +15,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Redesign the thread replies divider in the message replies list [#1354](https://github.com/GetStream/stream-chat-swiftui/pull/1354)
 
 ### 🐞 Fixed
+- Fix attachment downloads not using CDN requester for URL signing and custom headers [#1399](https://github.com/GetStream/stream-chat-swiftui/pull/1399)
 - Fix empty share sheet when sharing a video from the full-screen media viewer [#1418](https://github.com/GetStream/stream-chat-swiftui/pull/1418)
 - Fix swipe-to-reply icon layout for outgoing messages and RTL [#1402](https://github.com/GetStream/stream-chat-swiftui/pull/1402)
 - Fix unwanted border on the Edit button in Channel Info [#1402](https://github.com/GetStream/stream-chat-swiftui/pull/1402)

Package.swift

@@ -16,7 +16,7 @@ let package = Package(
         )
     ],
     dependencies: [
-        .package(url: "https://github.com/GetStream/stream-chat-swift.git", from: "5.0.0-beta")
+        .package(url: "https://github.com/GetStream/stream-chat-swift.git", revision: "ca835ce6621c027a6f97cf37ffe30d18d4d59be6")
     ],
     targets: [
         .target(

Sources/StreamChatSwiftUI/ChatChannel/ChannelInfo/MediaAttachmentsViewModel.swift

@@ -129,9 +129,9 @@ public final class MediaItem: Identifiable {
 
     @MainActor public var mediaAttachment: MediaAttachment? {
         if let videoAttachment {
-            return MediaAttachment(url: videoAttachment.videoURL, type: .video)
+            return MediaAttachment(from: videoAttachment)
         } else if let imageAttachment {
-            return MediaAttachment(url: imageAttachment.imageURL, type: .image)
+            return MediaAttachment(from: imageAttachment)
         }
         return nil
     }

Sources/StreamChatSwiftUI/ChatChannelList/MoreChannelActionsViewModel.swift

@@ -17,8 +17,7 @@ import UIKit
 
     /// Private vars.
     private lazy var channelNameFormatter = utils.channelNameFormatter
-    private lazy var imageLoader = utils.imageLoader
-    private lazy var imageCDN = utils.imageCDN
+    private lazy var mediaLoader = utils.mediaLoader
 
     /// Published vars.
     @Published var channelActions: [ChannelAction]

Sources/StreamChatSwiftUI/ChatComposer/AttachmentPicker/AttachmentMediaPicker/PhotoAssetLoader.swift

@@ -10,6 +10,7 @@ import SwiftUI
 /// Helper class that loads assets from the photo library.
 @MainActor public class PhotoAssetLoader: NSObject, ObservableObject {
     @Injected(\.chatClient) private var chatClient
+    @Injected(\.utils) private var utils
 
     @Published var loadedImages = [String: UIImage]()
 
@@ -57,7 +58,7 @@ import SwiftUI
         _ = url?.startAccessingSecurityScopedResource()
         if let assetURL = url,
            let file = try? AttachmentFile(url: assetURL),
-           file.size >= chatClient.maxAttachmentSize(for: assetURL) {
+           file.size >= chatClient.maxAttachmentSize(for: assetURL, fallbackSize: utils.composerConfig.maxAttachmentSize) {
             return true
         } else {
             return false

Sources/StreamChatSwiftUI/ChatComposer/ComposerConfig.swift

@@ -23,6 +23,10 @@ public final class ComposerConfig {
     public var adjustMessageOnSend: (String) -> (String)
     public var adjustMessageOnRead: (String) -> (String)
 
+    /// The fallback maximum attachment size in bytes when the server does not provide one.
+    /// The default value is 100 MB.
+    public var maxAttachmentSize: Int64
+
     public init(
         isVoiceRecordingEnabled: Bool = true,
         isVoiceRecordingAutoSendEnabled: Bool = false,
@@ -33,7 +37,8 @@ public final class ComposerConfig {
         gallerySupportedTypes: GallerySupportedTypes = .imagesAndVideo,
         maxGalleryAssetsCount: Int? = nil,
         adjustMessageOnSend: @escaping (String) -> (String) = { $0 },
-        adjustMessageOnRead: @escaping (String) -> (String) = { $0 }
+        adjustMessageOnRead: @escaping (String) -> (String) = { $0 },
+        maxAttachmentSize: Int64 = 100 * 1024 * 1024
     ) {
         self.inputViewMinHeight = inputViewMinHeight
         self.inputViewMaxHeight = inputViewMaxHeight
@@ -45,6 +50,7 @@ public final class ComposerConfig {
         self.maxGalleryAssetsCount = maxGalleryAssetsCount
         self.isVoiceRecordingEnabled = isVoiceRecordingEnabled
         self.isVoiceRecordingAutoSendEnabled = isVoiceRecordingAutoSendEnabled
+        self.maxAttachmentSize = maxAttachmentSize
     }
 }
 

Sources/StreamChatSwiftUI/ChatComposer/MessageComposerViewModel.swift

@@ -944,7 +944,7 @@ import SwiftUI
 
         do {
             let fileSize = try AttachmentFile(url: url).size
-            let canAdd = fileSize < chatClient.maxAttachmentSize(for: url)
+            let canAdd = fileSize <= chatClient.maxAttachmentSize(for: url, fallbackSize: utils.composerConfig.maxAttachmentSize)
             attachmentSizeExceeded = !canAdd
             return canAdd
         } catch {
@@ -1019,6 +1019,7 @@ final class FileAddedAsset {
 
 // The converter responsible to map attachments to assets and vice versa.
 @MainActor class MessageAttachmentsConverter {
+    @Injected(\.chatClient) private var chatClient
     @Injected(\.utils) var utils
 
     /// Converts the added assets to payloads.
@@ -1200,13 +1201,11 @@ final class FileAddedAsset {
             return
         }
 
-        utils.imageLoader.loadImage(
+        utils.mediaLoader.loadImage(
             url: imageAttachment.imageURL,
-            imageCDN: utils.imageCDN,
-            resize: false,
-            preferredSize: nil
+            options: ImageLoadOptions(resize: nil, cdnRequester: utils.cdnRequester)
         ) { result in
-            if let image = try? result.get() {
+            if let image = (try? result.get())?.image {
                 let imageAsset = AddedAsset(
                     image: image,
                     id: imageAttachment.id.rawValue,

Sources/StreamChatSwiftUI/ChatMessageList/FileAttachmentPreview.swift

@@ -14,9 +14,7 @@ public struct FileAttachmentPreview: View {
     @Injected(\.images) private var images
     @Injected(\.utils) private var utils
 
-    private var fileCDN: FileCDN {
-        utils.fileCDN
-    }
+    private var cdnRequester: CDNRequester { utils.cdnRequester }
 
     let attachment: ChatMessageFileAttachment
 
@@ -62,12 +60,14 @@ public struct FileAttachmentPreview: View {
                 }
             }
             .onAppear {
-                fileCDN.adjustedURL(for: url) { result in
-                    switch result {
-                    case let .success(url):
-                        adjustedUrl = url
-                    case let .failure(error):
-                        self.error = error
+                cdnRequester.fileRequest(for: url, options: .init()) { result in
+                    Task { @MainActor in
+                        switch result {
+                        case let .success(cdnRequest):
+                            adjustedUrl = cdnRequest.url
+                        case let .failure(error):
+                            self.error = error
+                        }
                     }
                 }
             }

Sources/StreamChatSwiftUI/ChatMessageList/FileAttachmentView.swift

@@ -232,7 +232,7 @@ struct DownloadShareAttachmentView<Payload: DownloadableAttachmentPayload>: View
     @State private var shareButtonShown: Bool
 
     var attachment: ChatMessageAttachment<Payload>
-    
+
     init(attachment: ChatMessageAttachment<Payload>) {
         self.attachment = attachment
         let downloadButtonShown: Bool = (attachment.uploadingState == nil || attachment.uploadingState?.state == .uploaded) && attachment.downloadingState == nil
@@ -279,12 +279,20 @@ struct DownloadShareAttachmentView<Payload: DownloadableAttachmentPayload>: View
         let messageId = attachment.id.messageId
         let cid = attachment.id.cid
         let messageController = chatClient.messageController(cid: cid, messageId: messageId)
-        messageController.downloadAttachment(attachment) { result in
-            if case .failure(let error) = result {
-                log.error("Error downloading attachment \(error.localizedDescription)")
-            } else {
-                downloadButtonShown = false
-                shareButtonShown = true
+        let cdnRequester = InjectedValues[\.utils].cdnRequester
+        cdnRequester.fileRequest(for: attachment.remoteURL, options: .init()) { result in
+            switch result {
+            case let .success(cdnRequest):
+                messageController.downloadAttachment(attachment, remoteURL: cdnRequest.url) { result in
+                    if case let .failure(error) = result {
+                        log.error("Error downloading attachment: \(error.localizedDescription)")
+                    } else {
+                        downloadButtonShown = false
+                        shareButtonShown = true
+                    }
+                }
+            case let .failure(error):
+                log.error("Error resolving CDN URL: \(error.localizedDescription)")
             }
         }
     }

Sources/StreamChatSwiftUI/ChatMessageList/Gallery/MediaViewer.swift

@@ -4,6 +4,7 @@
 
 import AVKit
 import StreamChat
+import StreamChatCommonUI
 import SwiftUI
 
 /// View used for displaying image attachments in a gallery.
@@ -316,19 +317,13 @@ public struct MediaViewerToolbarModifier: ViewModifier {
 
 struct StreamVideoPlayer: View {
     @Injected(\.utils) private var utils
-
-    private var fileCDN: FileCDN {
-        utils.fileCDN
-    }
-
-    private var avPlayerProvider: AVPlayerProvider {
-        utils.avPlayerProvider
-    }
+    @Injected(\.chatClient) private var chatClient
 
     let url: URL
 
     @State var avPlayer: AVPlayer?
     @State var error: Error?
+    @State private var isVisible = false
 
     init(url: URL) {
         self.url = url
@@ -342,17 +337,20 @@ struct StreamVideoPlayer: View {
             }
         }
         .onAppear {
+            isVisible = true
             guard avPlayer == nil else {
                 avPlayer?.play()
                 return
             }
-            fileCDN.adjustedURL(for: url) { result in
+            utils.mediaLoader.loadVideoAsset(
+                at: url,
+                options: VideoLoadOptions(cdnRequester: utils.cdnRequester)
+            ) { result in
+                guard isVisible else { return }
                 switch result {
-                case let .success(url):
-                    avPlayer = AVPlayer(url: url)
-                    try? AVAudioSession.sharedInstance().setCategory(.playback, options: [])
-                    avPlayer?.play()
-                    self.avPlayerProvider.player(for: url) { result in
+                case let .success(videoAsset):
+                    utils.avPlayerProvider.player(from: videoAsset) { result in
+                        guard isVisible else { return }
                         switch result {
                         case let .success(player):
                             self.avPlayer = player
@@ -368,6 +366,7 @@ struct StreamVideoPlayer: View {
             }
         }
         .onDisappear {
+            isVisible = false
             avPlayer?.pause()
         }
     }