Move media file loading logic to the SDK. (#702)

* Adopt getMediaFile for media previewing.

UnitTests/Sources/FileCacheTests.swift

@@ -1,78 +0,0 @@
-//
-// Copyright 2022 New Vector Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-import Foundation
-import XCTest
-
-@testable import ElementX
-
-class FileCacheTests: XCTestCase {
-    private var cache: FileCache!
-
-    override func setUp() {
-        cache = .default
-    }
-
-    override func tearDown() async throws {
-        try cache.removeAll()
-    }
-
-    func testExistence() throws {
-        let data = Data(repeating: 1, count: 32)
-        let key = "some_key"
-        let fileExtension = "mp4"
-
-        let url1 = try cache.store(data, with: fileExtension, forKey: key)
-        let url2 = cache.file(forKey: key, fileExtension: fileExtension)
-
-        XCTAssertEqual(url1, url2)
-    }
-
-    func testRemove() throws {
-        let data = Data(repeating: 1, count: 32)
-        let key = "some_key"
-        let fileExtension = "mp4"
-
-        _ = try cache.store(data, with: fileExtension, forKey: key)
-        try cache.remove(forKey: key, fileExtension: fileExtension)
-        let url = cache.file(forKey: key, fileExtension: fileExtension)
-
-        XCTAssertNil(url)
-    }
-
-    func testRemoveAll() throws {
-        let data1 = Data(repeating: 1, count: 32)
-        let key1 = "some_key_1"
-        let fileExtension1 = "mp4"
-
-        let data2 = Data(repeating: 1, count: 64)
-        let key2 = "some_key_2"
-        let fileExtension2 = "mp4"
-
-        _ = try cache.store(data1, with: fileExtension1, forKey: key1)
-        _ = try cache.store(data2, with: fileExtension2, forKey: key2)
-        try cache.removeAll()
-        let url1 = cache.file(forKey: key1, fileExtension: fileExtension1)
-        let url2 = cache.file(forKey: key2, fileExtension: fileExtension2)
-
-        XCTAssertNil(url1)
-        XCTAssertNil(url2)
-    }
-
-    func testRemoveAllWhenEmpty() throws {
-        XCTAssertNoThrow(try cache.removeAll())
-    }
-}

UnitTests/Sources/FilePreviewViewModelTests.swift

@@ -24,7 +24,7 @@ class FilePreviewScreenViewModelTests: XCTestCase {
     var context: FilePreviewViewModelType.Context!
 
     @MainActor override func setUpWithError() throws {
-        viewModel = FilePreviewViewModel(fileURL: URL(staticString: "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf"))
+        viewModel = FilePreviewViewModel(mediaFile: .unmanaged(url: URL(staticString: "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf")))
         context = viewModel.context
     }
 

UnitTests/Sources/MediaProvider/MediaLoaderTests.swift

@@ -23,7 +23,7 @@ final class MediaLoaderTests: XCTestCase {
         let mediaLoadingClient = MockMediaLoadingClient()
         let mediaLoader = MediaLoader(client: mediaLoadingClient)
         
-        let mediaSource = MediaSourceProxy(url: URL.documentsDirectory)
+        let mediaSource = MediaSourceProxy(url: URL.documentsDirectory, mimeType: nil)
         
         do {
             for _ in 1...10 {
@@ -40,7 +40,7 @@ final class MediaLoaderTests: XCTestCase {
         let mediaLoadingClient = MockMediaLoadingClient()
         let mediaLoader = MediaLoader(client: mediaLoadingClient)
         
-        let mediaSource = MediaSourceProxy(url: URL.documentsDirectory)
+        let mediaSource = MediaSourceProxy(url: URL.documentsDirectory, mimeType: nil)
         
         do {
             for _ in 1...10 {

UnitTests/Sources/MediaProvider/MediaProviderTests.swift

@@ -21,7 +21,6 @@ import XCTest
 @MainActor
 final class MediaProviderTests: XCTestCase {
     private let mediaLoader = MockMediaLoader()
-    private let fileCache = MockFileCache()
     private var imageCache: MockImageCache!
     private var backgroundTaskService = MockBackgroundTaskService()
     
@@ -31,7 +30,6 @@ final class MediaProviderTests: XCTestCase {
         imageCache = MockImageCache(name: "Test")
         mediaProvider = MediaProvider(mediaLoader: mediaLoader,
                                       imageCache: imageCache,
-                                      fileCache: fileCache,
                                       backgroundTaskService: backgroundTaskService)
     }
     
@@ -46,12 +44,13 @@ final class MediaProviderTests: XCTestCase {
         let key = "\(url.absoluteString){\(avatarSize.scaledValue),\(avatarSize.scaledValue)}"
         let imageForKey = UIImage()
         imageCache.retrievedImagesInMemory[key] = imageForKey
-        let image = mediaProvider.imageFromSource(MediaSourceProxy(url: url), size: avatarSize.scaledSize)
+        let image = mediaProvider.imageFromSource(MediaSourceProxy(url: url, mimeType: "image/jpeg"),
+                                                  size: avatarSize.scaledSize)
         XCTAssertEqual(image, imageForKey)
     }
     
     func test_whenImageFromSourceWithSourceNotNilAndImageNotCached_nilReturned() throws {
-        let image = mediaProvider.imageFromSource(MediaSourceProxy(url: URL.picturesDirectory),
+        let image = mediaProvider.imageFromSource(MediaSourceProxy(url: URL.picturesDirectory, mimeType: "image/jpeg"),
                                                   size: AvatarSize.room(on: .timeline).scaledSize)
         XCTAssertNil(image)
     }
@@ -62,7 +61,8 @@ final class MediaProviderTests: XCTestCase {
         let key = "\(url.absoluteString){\(avatarSize.scaledValue),\(avatarSize.scaledValue)}"
         let imageForKey = UIImage()
         imageCache.retrievedImagesInMemory[key] = imageForKey
-        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: url), size: avatarSize.scaledSize)
+        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: url, mimeType: "image/jpeg"),
+                                                             size: avatarSize.scaledSize)
         XCTAssertEqual(Result.success(imageForKey), result)
     }
     
@@ -72,7 +72,8 @@ final class MediaProviderTests: XCTestCase {
         let key = "\(url.absoluteString){\(avatarSize.scaledValue),\(avatarSize.scaledValue)}"
         let imageForKey = UIImage()
         imageCache.retrievedImages[key] = imageForKey
-        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: url), size: avatarSize.scaledSize)
+        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: url, mimeType: "image/jpeg"),
+                                                             size: avatarSize.scaledSize)
         XCTAssertEqual(Result.success(imageForKey), result)
     }
     
@@ -80,7 +81,8 @@ final class MediaProviderTests: XCTestCase {
         let avatarSize = AvatarSize.room(on: .timeline)
         let expectedImage = try loadTestImage()
         mediaLoader.mediaThumbnailData = expectedImage.pngData()
-        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: URL.picturesDirectory), size: avatarSize.scaledSize)
+        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: URL.picturesDirectory, mimeType: "image/jpeg"),
+                                                             size: avatarSize.scaledSize)
         switch result {
         case .success(let image):
             XCTAssertEqual(image.pngData(), expectedImage.pngData())
@@ -95,7 +97,8 @@ final class MediaProviderTests: XCTestCase {
         let key = "\(url.absoluteString){\(avatarSize.scaledValue),\(avatarSize.scaledValue)}"
         let expectedImage = try loadTestImage()
         mediaLoader.mediaThumbnailData = expectedImage.pngData()
-        _ = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: url), size: avatarSize.scaledSize)
+        _ = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: url, mimeType: "image/jpeg"),
+                                                    size: avatarSize.scaledSize)
         let storedImage = try XCTUnwrap(imageCache.storedImages[key])
         XCTAssertEqual(expectedImage.pngData(), storedImage.pngData())
     }
@@ -103,7 +106,8 @@ final class MediaProviderTests: XCTestCase {
     func test_whenLoadImageFromSourceAndImageNotCachedAndRetrieveImageFailsAndNoAvatarSize_imageContentIsLoaded() async throws {
         let expectedImage = try loadTestImage()
         mediaLoader.mediaContentData = expectedImage.pngData()
-        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: URL.picturesDirectory), size: nil)
+        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: URL.picturesDirectory, mimeType: "image/jpeg"),
+                                                             size: nil)
         switch result {
         case .success(let image):
             XCTAssertEqual(image.pngData(), expectedImage.pngData())
@@ -113,7 +117,7 @@ final class MediaProviderTests: XCTestCase {
     }
     
     func test_whenLoadImageFromSourceAndImageNotCachedAndRetrieveImageFailsAndLoadImageThumbnailFails_errorIsThrown() async throws {
-        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: URL.picturesDirectory),
+        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: URL.picturesDirectory, mimeType: "image/jpeg"),
                                                              size: AvatarSize.room(on: .timeline).scaledSize)
         switch result {
         case .success:
@@ -124,7 +128,8 @@ final class MediaProviderTests: XCTestCase {
     }
     
     func test_whenLoadImageFromSourceAndImageNotCachedAndRetrieveImageFailsAndNoAvatarSizeAndLoadImageContentFails_errorIsThrown() async throws {
-        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: URL.picturesDirectory), size: nil)
+        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: URL.picturesDirectory, mimeType: "image/jpeg"),
+                                                             size: nil)
         switch result {
         case .success:
             XCTFail("Should fail")
@@ -135,7 +140,7 @@ final class MediaProviderTests: XCTestCase {
     
     func test_whenLoadImageFromSourceAndImageNotCachedAndRetrieveImageFailsAndImageThumbnailIsLoadedWithCorruptedData_errorIsThrown() async throws {
         mediaLoader.mediaThumbnailData = Data()
-        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: URL.picturesDirectory),
+        let result = await mediaProvider.loadImageFromSource(MediaSourceProxy(url: URL.picturesDirectory, mimeType: "image/jpeg"),
                                                              size: AvatarSize.room(on: .timeline).scaledSize)
         switch result {
         case .success:
@@ -145,51 +150,18 @@ final class MediaProviderTests: XCTestCase {
         }
     }
     
-    func test_whenFileFromSourceWithSourceNil_nilIsReturned() throws {
-        let url = mediaProvider.fileFromSource(nil, fileExtension: "png")
-        XCTAssertNil(url)
-    }
-    
-    func test_whenFileFromSourceWithSource_correctValuesAreReturned() throws {
-        let expectedURL = URL(filePath: "/some/file/path")
-        fileCache.fileURLToReturn = expectedURL
-        let url = mediaProvider.fileFromSource(MediaSourceProxy(url: URL(staticString: "test/test1")), fileExtension: "png")
-        XCTAssertEqual(fileCache.fileKey, "test1")
-        XCTAssertEqual(fileCache.fileExtension, "png")
-        XCTAssertEqual(url?.absoluteString, expectedURL.absoluteString)
-    }
-    
     func test_whenLoadFileFromSourceAndFileFromSourceExists_urlIsReturned() async throws {
         let expectedURL = URL(filePath: "/some/file/path")
-        let expectedResult: Result<URL, MediaProviderError> = .success(expectedURL)
-        fileCache.fileURLToReturn = expectedURL
-        let result = await mediaProvider.loadFileFromSource(MediaSourceProxy(url: URL(staticString: "test/test1")), fileExtension: "png")
+        let expectedResult: Result<MediaFileHandleProxy, MediaProviderError> = .success(.unmanaged(url: expectedURL))
+        mediaLoader.mediaFileURL = expectedURL
+        let result = await mediaProvider.loadFileFromSource(MediaSourceProxy(url: URL(staticString: "test/test1"), mimeType: "video/mp4"))
         XCTAssertEqual(result, expectedResult)
     }
     
-    func test_whenLoadFileFromSourceAndNoFileFromSourceExists_mediaLoadedFromSource() async throws {
-        let expectedURL = URL(filePath: "/some/file/path")
-        let expectedResult: Result<URL, MediaProviderError> = .success(expectedURL)
-        mediaLoader.mediaContentData = try loadTestImage().pngData()
-        fileCache.storeURLToReturn = expectedURL
-        let result = await mediaProvider.loadFileFromSource(MediaSourceProxy(url: URL(staticString: "test/test1")), fileExtension: "png")
-        XCTAssertEqual(result, expectedResult)
-        XCTAssertEqual(mediaLoader.mediaContentData, fileCache.storedData)
-        XCTAssertEqual("test1", fileCache.storedFileKey)
-        XCTAssertEqual("png", fileCache.storedFileExtension)
-    }
-    
     func test_whenLoadFileFromSourceAndNoFileFromSourceExistsAndLoadContentSourceFails_failureIsReturned() async throws {
-        let expectedResult: Result<URL, MediaProviderError> = .failure(.failedRetrievingImage)
-        mediaLoader.mediaContentData = nil
-        let result = await mediaProvider.loadFileFromSource(MediaSourceProxy(url: URL(staticString: "test/test1")), fileExtension: "png")
-        XCTAssertEqual(result, expectedResult)
-    }
-    
-    func test_whenLoadFileFromSourceAndNoFileFromSourceExistsAndStoreDataFails_failureIsReturned() async throws {
-        let expectedResult: Result<URL, MediaProviderError> = .failure(.failedRetrievingImage)
-        mediaLoader.mediaContentData = try loadTestImage().pngData()
-        let result = await mediaProvider.loadFileFromSource(MediaSourceProxy(url: URL(staticString: "test/test1")), fileExtension: "png")
+        let expectedResult: Result<MediaFileHandleProxy, MediaProviderError> = .failure(.failedRetrievingFile)
+        mediaLoader.mediaFileURL = nil
+        let result = await mediaProvider.loadFileFromSource(MediaSourceProxy(url: URL(staticString: "test/test1"), mimeType: "video/mp4"))
         XCTAssertEqual(result, expectedResult)
     }
     

UnitTests/Sources/MediaProvider/MockFileCache.swift

@@ -1,52 +0,0 @@
-//
-// Copyright 2022 New Vector Ltd
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-@testable import ElementX
-import Foundation
-
-enum MockFileCacheError: Error {
-    case someError
-}
-
-class MockFileCache: FileCacheProtocol {
-    var fileKey: String?
-    var fileExtension: String?
-    var fileURLToReturn: URL?
-    var storedData: Data?
-    var storedFileExtension: String?
-    var storedFileKey: String?
-    var storeURLToReturn: URL?
-    
-    func file(forKey key: String, fileExtension: String) -> URL? {
-        fileKey = key
-        self.fileExtension = fileExtension
-        return fileURLToReturn
-    }
-    
-    func store(_ data: Data, with fileExtension: String, forKey key: String) throws -> URL {
-        storedData = data
-        storedFileExtension = fileExtension
-        storedFileKey = key
-        if let storeURLToReturn {
-            return storeURLToReturn
-        } else {
-            throw MockFileCacheError.someError
-        }
-    }
-    
-    func remove(forKey key: String, fileExtension: String) throws { }
-    
-    func removeAll() throws { }
-}

UnitTests/Sources/MediaProvider/MockMediaLoader.swift

@@ -23,6 +23,7 @@ enum MockMediaLoaderError: Error {
 class MockMediaLoader: MediaLoaderProtocol {
     var mediaContentData: Data?
     var mediaThumbnailData: Data?
+    var mediaFileURL: URL?
     
     func loadMediaContentForSource(_ source: ElementX.MediaSourceProxy) async throws -> Data {
         if let mediaContentData {
@@ -39,4 +40,12 @@ class MockMediaLoader: MediaLoaderProtocol {
             throw MockMediaLoaderError.someError
         }
     }
+    
+    func loadMediaFileForSource(_ source: MediaSourceProxy) async throws -> MediaFileHandleProxy {
+        if let mediaFileURL {
+            return .unmanaged(url: mediaFileURL)
+        } else {
+            throw MockMediaLoaderError.someError
+        }
+    }
 }

UnitTests/Sources/MessageTimelineItemTests.swift

@@ -0,0 +1,167 @@
+//
+// Copyright 2023 New Vector Ltd
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+@testable import ElementX
+import MatrixRustSDK
+import XCTest
+
+// swiftlint:disable force_unwrapping
+class MessageTimelineItemTests: XCTestCase {
+    // MARK: Image
+    
+    func testImageContentType() {
+        let mimetype = "image/gif"
+        let imageContent = ImageMessageContent(body: "amazing.gif",
+                                               source: mediaSourceFromUrl(url: "mxc://doesnt/matter"),
+                                               info: makeImageInfo(mimetype: mimetype))
+        let messageItem = MockEventTimelineItem.message(from: imageContent)
+        XCTAssertEqual(messageItem.contentType, .gif)
+    }
+    
+    func testImageContentTypeWithoutMimetype() {
+        let imageContent = ImageMessageContent(body: "amazing.jpeg",
+                                               source: mediaSourceFromUrl(url: "mxc://doesnt/matter"),
+                                               info: makeImageInfo(mimetype: nil))
+        let messageItem = MockEventTimelineItem.message(from: imageContent)
+        XCTAssertEqual(messageItem.contentType, .jpeg)
+    }
+    
+    func makeImageInfo(mimetype: String?) -> ImageInfo {
+        ImageInfo(height: nil,
+                  width: nil,
+                  mimetype: mimetype,
+                  size: nil,
+                  thumbnailInfo: nil,
+                  thumbnailSource: nil,
+                  blurhash: nil)
+    }
+    
+    // MARK: Video
+    
+    func testVideoContentType() {
+        let mimetype = "video/x-msvideo"
+        let imageContent = VideoMessageContent(body: "amazing.avi",
+                                               source: mediaSourceFromUrl(url: "mxc://doesnt/matter"),
+                                               info: makeVideoInfo(mimetype: mimetype))
+        let messageItem = MockEventTimelineItem.message(from: imageContent)
+        XCTAssertEqual(messageItem.contentType, .avi)
+    }
+    
+    func testVideoContentTypeWithoutMimetype() {
+        let imageContent = VideoMessageContent(body: "amazing.mp4",
+                                               source: mediaSourceFromUrl(url: "mxc://doesnt/matter"),
+                                               info: makeVideoInfo(mimetype: nil))
+        let messageItem = MockEventTimelineItem.message(from: imageContent)
+        XCTAssertEqual(messageItem.contentType, .mpeg4Movie)
+    }
+    
+    func makeVideoInfo(mimetype: String?) -> VideoInfo {
+        VideoInfo(duration: nil,
+                  height: nil,
+                  width: nil,
+                  mimetype: mimetype,
+                  size: nil,
+                  thumbnailInfo: nil,
+                  thumbnailSource: nil,
+                  blurhash: nil)
+    }
+    
+    // MARK: Audio
+    
+    func testAudioContentType() {
+        let mimetype = "audio/mp3"
+        let imageContent = AudioMessageContent(body: "amazing.mp3",
+                                               source: mediaSourceFromUrl(url: "mxc://doesnt/matter"),
+                                               info: makeAudioInfo(mimetype: mimetype))
+        let messageItem = MockEventTimelineItem.message(from: imageContent)
+        XCTAssertEqual(messageItem.contentType, .mp3)
+    }
+    
+    func testAudioContentTypeWithoutMimetype() {
+        let imageContent = AudioMessageContent(body: "amazing.m4a",
+                                               source: mediaSourceFromUrl(url: "mxc://doesnt/matter"),
+                                               info: makeAudioInfo(mimetype: nil))
+        let messageItem = MockEventTimelineItem.message(from: imageContent)
+        XCTAssertTrue(messageItem.contentType!.conforms(to: .mpeg4Audio))
+    }
+    
+    func makeAudioInfo(mimetype: String?) -> AudioInfo {
+        AudioInfo(duration: nil, size: nil, mimetype: mimetype)
+    }
+    
+    // MARK: File
+    
+    func testFileContentType() {
+        let mimetype = "text"
+        let imageContent = FileMessageContent(body: "amazing.txt",
+                                              source: mediaSourceFromUrl(url: "mxc://doesnt/matter"),
+                                              info: makeFileInfo(mimetype: mimetype))
+        let messageItem = MockEventTimelineItem.message(from: imageContent)
+        XCTAssertEqual(messageItem.contentType, .plainText)
+    }
+    
+    func testFileContentTypeWithoutMimetype() {
+        let imageContent = FileMessageContent(body: "amazing.rtf",
+                                              source: mediaSourceFromUrl(url: "mxc://doesnt/matter"),
+                                              info: makeFileInfo(mimetype: nil))
+        let messageItem = MockEventTimelineItem.message(from: imageContent)
+        XCTAssertEqual(messageItem.contentType, .rtf)
+    }
+    
+    func makeFileInfo(mimetype: String?) -> FileInfo {
+        FileInfo(mimetype: mimetype, size: nil, thumbnailInfo: nil, thumbnailSource: nil)
+    }
+}
+
+// MARK: - Mocks
+
+// swiftlint:disable force_cast
+private struct MockEventTimelineItem: EventTimelineItemProtocol {
+    static func message<Content: MessageContentProtocol>(from content: Content) -> MessageTimelineItem<Content> {
+        let item = MockEventTimelineItem(underlyingContent: content)
+        return MessageTimelineItem(item: item, content: content)
+    }
+    
+    let underlyingContent: MessageContentProtocol
+    
+    func content() -> MatrixRustSDK.TimelineItemContent { underlyingContent as! TimelineItemContent }
+    
+    func eventId() -> String? { UUID().uuidString }
+    
+    func fmtDebug() -> String { "MockEvent" }
+    
+    func isEditable() -> Bool { false }
+    
+    func isLocal() -> Bool { false }
+    
+    func isOwn() -> Bool { false }
+    
+    func isRemote() -> Bool { true }
+    
+    func localSendState() -> MatrixRustSDK.EventSendState? { nil }
+    
+    func raw() -> String? { nil }
+    
+    func reactions() -> [MatrixRustSDK.Reaction]? { nil }
+    
+    func sender() -> String { "@user:server.com" }
+    
+    func senderProfile() -> MatrixRustSDK.ProfileTimelineDetails { .unavailable }
+    
+    func timestamp() -> UInt64 { 0 }
+    
+    func uniqueIdentifier() -> String { eventId() ?? "" }
+}