Refactoring

submodules/TelegramCore/Sources/TelegramEngine/Resources/TelegramEngineResources.swift

@@ -1,6 +1,150 @@
+import Foundation
 import SwiftSignalKit
 import Postbox
 
+public final class EngineMediaResource: Equatable {
+    public struct ByteRange {
+        public enum Priority {
+            case `default`
+            case elevated
+            case maximum
+        }
+
+        public var range: Range<Int>
+        public var priority: Priority
+
+        public init(range: Range<Int>, priority: Priority) {
+            self.range = range
+            self.priority = priority
+        }
+    }
+
+    public final class Fetch {
+        public enum Result {
+            case dataPart(resourceOffset: Int, data: Data, range: Range<Int>, complete: Bool)
+            case resourceSizeUpdated(Int)
+            case progressUpdated(Float)
+            case replaceHeader(data: Data, range: Range<Int>)
+            case moveLocalFile(path: String)
+            case moveTempFile(file: TempBoxFile)
+            case copyLocalItem(MediaResourceDataFetchCopyLocalItem)
+            case reset
+        }
+
+        public enum Error {
+            case generic
+        }
+
+        public let signal: (
+            Signal<[EngineMediaResource.ByteRange], NoError>
+        ) -> Signal<Result, Error>
+
+        public init(_ signal: @escaping (
+            Signal<[EngineMediaResource.ByteRange], NoError>
+        ) -> Signal<Result, Error>) {
+            self.signal = signal
+        }
+    }
+
+    public final class ResourceData {
+        public let path: String
+        public let availableSize: Int
+        public let isComplete: Bool
+
+        public init(
+            path: String,
+            availableSize: Int,
+            isComplete: Bool
+        ) {
+            self.path = path
+            self.availableSize = availableSize
+            self.isComplete = isComplete
+        }
+    }
+
+    public struct Id: Equatable, Hashable {
+        public var stringRepresentation: String
+
+        public init(_ stringRepresentation: String) {
+            self.stringRepresentation = stringRepresentation
+        }
+
+        public init(_ id: MediaResourceId) {
+            self.stringRepresentation = id.stringRepresentation
+        }
+    }
+
+    private let resource: MediaResource
+
+    public init(_ resource: MediaResource) {
+        self.resource = resource
+    }
+
+    public func _asResource() -> MediaResource {
+        return self.resource
+    }
+
+    public var id: Id {
+        return Id(self.resource.id)
+    }
+
+    public static func ==(lhs: EngineMediaResource, rhs: EngineMediaResource) -> Bool {
+        return lhs.resource.isEqual(to: rhs.resource)
+    }
+}
+
+public extension MediaResource {
+    func fetch(engine: TelegramEngine, parameters: MediaResourceFetchParameters?) -> EngineMediaResource.Fetch {
+        return EngineMediaResource.Fetch { ranges in
+            return Signal { subscriber in
+                return engine.account.postbox.mediaBox.fetchResource!(
+                    self,
+                    ranges |> map { ranges -> [(Range<Int>, MediaBoxFetchPriority)] in
+                        return ranges.map { range -> (Range<Int>, MediaBoxFetchPriority) in
+                            let mappedPriority: MediaBoxFetchPriority
+                            switch range.priority {
+                            case .default:
+                                mappedPriority = .default
+                            case .elevated:
+                                mappedPriority = .elevated
+                            case .maximum:
+                                mappedPriority = .maximum
+                            }
+                            return (range.range, mappedPriority)
+                        }
+                    },
+                    parameters
+                ).start(next: { result in
+                    let mappedResult: EngineMediaResource.Fetch.Result
+                    switch result {
+                    case let .dataPart(resourceOffset, data, range, complete):
+                        mappedResult = .dataPart(resourceOffset: resourceOffset, data: data, range: range, complete: complete)
+                    case let .resourceSizeUpdated(size):
+                        mappedResult = .resourceSizeUpdated(size)
+                    case let .progressUpdated(progress):
+                        mappedResult = .progressUpdated(progress)
+                    case let .replaceHeader(data, range):
+                        mappedResult = .replaceHeader(data: data, range: range)
+                    case let .moveLocalFile(path):
+                        mappedResult = .moveLocalFile(path: path)
+                    case let .moveTempFile(file):
+                        mappedResult = .moveTempFile(file: file)
+                    case let .copyLocalItem(item):
+                        mappedResult = .copyLocalItem(item)
+                    case .reset:
+                        mappedResult = .reset
+                    }
+                    subscriber.putNext(mappedResult)
+                }, error: { _ in
+                    subscriber.putError(.generic)
+                }, completed: {
+                    subscriber.putCompletion()
+                })
+            }
+        }
+    }
+}
+
 public extension TelegramEngine {
     final class Resources {
         private let account: Account
@@ -17,8 +161,20 @@ public extension TelegramEngine {
             return _internal_collectCacheUsageStats(account: self.account, peerId: peerId, additionalCachePaths: additionalCachePaths, logFilesPath: logFilesPath)
         }
 
-        public func clearCachedMediaResources(mediaResourceIds: Set<WrappedMediaResourceId>) -> Signal<Void, NoError> {
+        public func clearCachedMediaResources(mediaResourceIds: Set<MediaResourceId>) -> Signal<Void, NoError> {
             return _internal_clearCachedMediaResources(account: self.account, mediaResourceIds: mediaResourceIds)
         }
+
+        public func data(id: String) -> Signal<EngineMediaResource.ResourceData, NoError> {
+            preconditionFailure()
+        }
+
+        public func fetch(id: String, fetch: EngineMediaResource.Fetch) -> Signal<Never, NoError> {
+            preconditionFailure()
+        }
+
+        public func cancelAllFetches(id: String) {
+            preconditionFailure()
+        }
     }
 }