added support for phAssets; removed unnecessary macCatalyst workaround;

Author: Christian Elies

Sources/RemoteImage/private/Models/RemoteImageState.swift

@@ -10,7 +10,7 @@ import Foundation
 
 enum RemoteImageState {
     case error(_ error: Error)
-    case image(_ image: RemoteImageType)
+    case image(_ image: PlatformSpecificImageType)
     case loading
 }
 

Sources/RemoteImage/private/Services/PhotoKitService.swift

@@ -0,0 +1,41 @@
+import Photos
+
+protocol PhotoKitServiceProvider {
+	var photoKitService: PhotoKitServiceProtocol { get }
+}
+
+protocol PhotoKitServiceProtocol {
+    func getPhotoData(localIdentifier: String,
+                      success: @escaping (Data) -> Void,
+                      failure: @escaping (Error) -> Void)
+}
+
+final class PhotoKitService {
+	
+}
+
+extension PhotoKitService: PhotoKitServiceProtocol {
+    func getPhotoData(localIdentifier: String,
+                      success: @escaping (Data) -> Void,
+                      failure: @escaping (Error) -> Void) {
+        let fetchAssetsResult = PHAsset.fetchAssets(withLocalIdentifiers: [localIdentifier], options: nil)
+        guard let phAsset = fetchAssetsResult.firstObject else {
+            failure(PhotoKitServiceError.phAssetNotFound(localIdentifier: localIdentifier))
+            return
+        }
+        
+        let options = PHImageRequestOptions()
+        options.isNetworkAccessAllowed = true
+        PHImageManager.default().requestImageDataAndOrientation(for: phAsset,
+                                                                options: options,
+                                                                resultHandler: { data, _, _, info in
+            if let error = info?[PHImageErrorKey] as? Error {
+                failure(error)
+            } else if let data = data {
+                success(data)
+            } else {
+                failure(PhotoKitServiceError.missingData)
+            }
+        })
+    }
+}

Sources/RemoteImage/private/Services/RemoteImageServiceDependencies.swift

@@ -0,0 +1,20 @@
+//
+//  RemoteImageServiceDependencies.swift
+//  
+//
+//  Created by Christian Elies on 29.10.19.
+//
+
+import Foundation
+
+protocol RemoteImageServiceDependenciesProtocol: PhotoKitServiceProvider {
+    
+}
+
+struct RemoteImageServiceDependencies: RemoteImageServiceDependenciesProtocol {
+    let photoKitService: PhotoKitServiceProtocol
+    
+    init() {
+        photoKitService = PhotoKitService()
+    }
+}

Sources/RemoteImage/public/Models/PhotoKitServiceError.swift

@@ -0,0 +1,48 @@
+import Foundation
+
+public enum PhotoKitServiceError: Error {
+    case missingData
+    case phAssetNotFound(localIdentifier: String)
+}
+
+extension PhotoKitServiceError: LocalizedError {
+    public var errorDescription: String? {
+        switch self {
+        case .missingData:
+            return "The asset could not be loaded."
+        case .phAssetNotFound(let localIdentifier):
+            return "A PHAsset with the identifier \(localIdentifier) was not found."
+        }
+    }
+    
+    public var failureReason: String? {
+        switch self {
+        case .missingData:
+            return "The asset data could not be fetched. Maybe you are not connected to the internet."
+        case .phAssetNotFound(let localIdentifier):
+            return "An asset with the identifier \(localIdentifier) doesn't exist anymore."
+        }
+    }
+    
+    public var recoverySuggestion: String? {
+        switch self {
+        case .missingData:
+            return "Check your internet connection or try again later."
+        default:
+            return nil
+        }
+    }
+}
+
+extension PhotoKitServiceError: CustomNSError {
+    public static var errorDomain: String { String(describing: PhotoKitService.self) }
+
+    public var errorCode: Int {
+        switch self {
+        case .missingData:
+            return 0
+        case .phAssetNotFound:
+            return 1
+        }
+    }
+}

Sources/RemoteImage/public/Models/PlatformSpecificImageType.swift

@@ -0,0 +1,17 @@
+//
+//  PlatformSpecificImageType.swift
+//  
+//
+//  Created by Christian Elies on 08.09.19.
+//
+
+import Foundation
+
+#if canImport(UIKit)
+import UIKit
+public typealias PlatformSpecificImageType = UIImage
+
+#elseif os(macOS)
+import AppKit
+public typealias PlatformSpecificImageType = NSImage
+#endif

Sources/RemoteImage/public/Models/RemoteImageType.swift

@@ -2,15 +2,12 @@
 //  RemoteImageType.swift
 //  
 //
-//  Created by Christian Elies on 08.09.19.
+//  Created by Christian Elies on 29.10.19.
 //
 
 import Foundation
 
-#if canImport(UIKit)
-import UIKit
-public typealias RemoteImageType = UIImage
-#elseif os(macOS)
-import AppKit
-public typealias RemoteImageType = NSImage
-#endif
+public enum RemoteImageType {
+    case phAsset(localIdentifier: String)
+    case url(_ url: URL)
+}

Sources/RemoteImage/public/Services/RemoteImageService.swift

@@ -10,19 +10,29 @@ import Combine
 import Foundation
 
 public final class RemoteImageService: NSObject, ObservableObject {
+    private let dependencies: RemoteImageServiceDependenciesProtocol
     private var cancellable: AnyCancellable?
 
-    var state: RemoteImageState = .loading {
-        didSet {
-            objectWillChange.send()
-        }
-    }
+    @Published var state: RemoteImageState = .loading
 
-    public static let cache = NSCache<NSURL, RemoteImageType>()
+    public static let cache = NSCache<NSObject, PlatformSpecificImageType>()
 
-    public let objectWillChange = PassthroughSubject<Void, Never>()
+    init(dependencies: RemoteImageServiceDependenciesProtocol) {
+        self.dependencies = dependencies
+    }
 
-    func fetchImage(atURL url: URL) {
+    func fetchImage(ofType type: RemoteImageType) {
+        switch type {
+        case .url(let url):
+            fetchImage(atURL: url)
+        case .phAsset(let localIdentifier):
+            fetchImage(withLocalIdentifier: localIdentifier)
+        }
+    }
+}
+
+extension RemoteImageService {
+    private func fetchImage(atURL url: URL) {
         cancellable?.cancel()
 
         if let image = RemoteImageService.cache.object(forKey: url as NSURL) {
@@ -34,7 +44,7 @@ public final class RemoteImageService: NSObject, ObservableObject {
         let urlRequest = URLRequest(url: url)
 
         cancellable = urlSession.dataTaskPublisher(for: urlRequest)
-            .map { RemoteImageType(data: $0.data) }
+            .map { PlatformSpecificImageType(data: $0.data) }
             .receive(on: RunLoop.main)
             .sink(receiveCompletion: { completion in
                 switch completion {
@@ -51,4 +61,22 @@ public final class RemoteImageService: NSObject, ObservableObject {
                 }
             }
     }
+    
+    private func fetchImage(withLocalIdentifier localIdentifier: String) {
+        if let image = RemoteImageService.cache.object(forKey: localIdentifier as NSString) {
+            state = .image(image)
+            return
+        }
+        
+        dependencies.photoKitService.getPhotoData(localIdentifier: localIdentifier, success: { data in
+            if let image = PlatformSpecificImageType(data: data) {
+                RemoteImageService.cache.setObject(image, forKey: localIdentifier as NSString)
+                self.state = .image(image)
+            } else {
+                self.state = .error(RemoteImageServiceError.couldNotCreateImage)
+            }
+        }) { error in
+            self.state = .error(error)
+        }
+    }
 }

Sources/RemoteImage/public/Services/RemoteImageServiceFactory.swift

@@ -0,0 +1,15 @@
+//
+//  RemoteImageServiceFactory.swift
+//  
+//
+//  Created by Christian Elies on 29.10.19.
+//
+
+import Foundation
+
+public final class RemoteImageServiceFactory {
+    public static func makeRemoteImageService() -> RemoteImageService {
+        let dependencies = RemoteImageServiceDependencies()
+        return RemoteImageService(dependencies: dependencies)
+    }
+}

Sources/RemoteImage/public/Views/RemoteImage.swift

@@ -10,16 +10,12 @@ import Combine
 import SwiftUI
 
 public struct RemoteImage<ErrorView: View, ImageView: View, LoadingView: View>: View {
-    private let url: URL
+    private let type: RemoteImageType
     private let errorView: (Error) -> ErrorView
     private let imageView: (Image) -> ImageView
     private let loadingView: () -> LoadingView
 
-    #if !targetEnvironment(macCatalyst)
-    @ObservedObject private var service: RemoteImageService = RemoteImageService()
-    #else
-    @EnvironmentObject var service: RemoteImageService
-    #endif
+    @ObservedObject private var service = RemoteImageServiceFactory.makeRemoteImageService()
 
     public var body: AnyView {
         switch service.state {
@@ -45,14 +41,14 @@ public struct RemoteImage<ErrorView: View, ImageView: View, LoadingView: View>:
                 return AnyView(
                     loadingView()
                     .onAppear {
-                        self.service.fetchImage(atURL: self.url)
+                        self.service.fetchImage(ofType: self.type)
                     }
                 )
         }
     }
 
-    public init(url: URL, @ViewBuilder errorView: @escaping (Error) -> ErrorView, @ViewBuilder imageView: @escaping (Image) -> ImageView, @ViewBuilder loadingView: @escaping () -> LoadingView) {
-        self.url = url
+    public init(type: RemoteImageType, @ViewBuilder errorView: @escaping (Error) -> ErrorView, @ViewBuilder imageView: @escaping (Image) -> ImageView, @ViewBuilder loadingView: @escaping () -> LoadingView) {
+        self.type = type
         self.errorView = errorView
         self.imageView = imageView
         self.loadingView = loadingView
@@ -63,7 +59,7 @@ public struct RemoteImage<ErrorView: View, ImageView: View, LoadingView: View>:
 struct RemoteImage_Previews: PreviewProvider {
     static var previews: some View {
         let url = URL(string: "https://images.unsplash.com/photo-1524419986249-348e8fa6ad4a?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=crop&w=1950&q=80")!
-        return RemoteImage(url: url, errorView: { error in
+        return RemoteImage(type: .url(url), errorView: { error in
             Text(error.localizedDescription)
         }, imageView: { image in
             image