Response image addition

Author: burak.uzunboy

Package.swift

@@ -22,8 +22,8 @@ let package = Package(
         .target(
             name: "UsefulNetworkLayer",
             dependencies: ["CoreUsefulSDK"]),
-//        .testTarget(
-//        name: "iOSUsefulNetworkLayerTests",
-//        dependencies: ["UsefulNetworkLayer", "CoreUsefulSDK"]),
+        .testTarget(
+        name: "iOSUsefulNetworkLayerTests",
+        dependencies: ["UsefulNetworkLayer", "CoreUsefulSDK"]),
     ]
 )

Sources/UsefulNetworkLayer/Extensions/UIImage+ResponseImage.swift

@@ -0,0 +1,50 @@
+//
+//  UIImage+ResponseImage.swift
+//  MyPet
+//
+//  Created by Burak Uzunboy on 23.05.20.
+//  Copyright © 2020 BUZ. All rights reserved.
+//
+
+import UIKit
+
+/**
+ Extends UIImage with Network Layer compatible `ResponseImage` class. With that, image class can directly respond to URLs.
+ */
+extension UIImage {
+    
+    /// Returns immediately if image is available on the cache, otherwise requests from Network Layer and calls completion block.
+    @discardableResult
+    class func fromURL(_ url: URL, completion: @escaping (_ image: UIImage?)->()) -> UIImage? {
+        let api = APIConfiguration(url: url, responseBodyObject: ResponseImage.self, cachingTime: NetworkLayer.CachingTime(seconds: 60*60*24))
+        
+        api.request { (result) in
+            switch result {
+            case .error(_):
+                completion(nil)
+            case .success(let response):
+                completion(response.responseBody.image)
+            }
+        }
+        
+        if let img = UIImage.fromCache(url) {
+            return img
+        }
+        return nil
+    }
+    
+    /// Returns immediately the image if it is available on the cache.
+    class func fromCache(_ url: URL) -> UIImage? {
+        let api = APIConfiguration(url: url, responseBodyObject: ResponseImage.self)
+        guard let response = NetworkLayer.cache?.cachedResponse(for: URLRequest(url: api.requestURL)) else { return nil }
+        return UIImage(data: response.data)
+    }
+    
+    /// Downloads image and saves to the cache for future uses.
+    class func download(_ url: URL) {
+        let api = APIConfiguration(url: url, responseBodyObject: ResponseImage.self, priority: .veryLow, isMainOperation: false)
+        api.request { (_) in }
+    }
+    
+}
+

Sources/UsefulNetworkLayer/Extensions/UIImageView+ImageURL.swift

@@ -0,0 +1,121 @@
+//
+//  UIImageView+ImageURL.swift
+//  MyPet
+//
+//  Created by Burak Uzunboy on 23.05.20.
+//  Copyright © 2020 BUZ. All rights reserved.
+//
+
+import UIKit
+
+extension UIImageView {
+    
+    /// Creates and sets Image to the ImageView from given remote URL.
+    ///
+    /// During the loading process, this method is also capable to add activity indicator.
+    /// Change tag value if other method will be called also to change image of the imageview to override again.
+    public func imageFromUrl(urlString: String?, fallback: UIImage?, errorCompletion: ((_ error: NSError)->())? = nil){
+        guard let urlStr = urlString, let url = URL(string: urlStr) else {
+            self.image = fallback
+            return
+        }
+        
+        return self.imageFromUrl(url: url, fallback: fallback, errorCompletion: errorCompletion, completion: nil)
+    }
+    
+    /**
+     Sets image to the image view.
+     - parameter url: URL of the image source
+     - parameter completion: Returns the image that set to imageview even it fallbacks to error. If `fallback` is set, at worst it will return the fallback.
+     - parameter errorCompletion: This block will be called if any error happens
+     */
+    public func imageFromUrl(url: URL?, fallback: UIImage?,
+                             errorCompletion: ((_ error: NSError)->())? = nil,
+                             completion: ((_ image: UIImage?)->())?) {
+        guard let url = url else {
+            self.image = fallback
+            completion?(image)
+            return
+        }
+        
+        let dateTag = Int(Date().timeIntervalSince1970 * 1000)
+        self.tag = dateTag
+        self.image = nil
+        
+        // if image can be gathered from cache directly, use it.
+        if let image = UIImage.fromCache(url) {
+            self.image = image
+            completion?(image)
+            return
+        }
+        
+        let activityIndicator = UIActivityIndicatorView(style: .whiteLarge)
+        activityIndicator.color = .orange
+        activityIndicator.center = self.center
+        activityIndicator.startAnimating()
+        self.addSubview(activityIndicator)
+        
+        activityIndicator.translatesAutoresizingMaskIntoConstraints = false
+        activityIndicator.centerXAnchor.constraint(equalTo: self.centerXAnchor).isActive = true
+        activityIndicator.centerYAnchor.constraint(equalTo: self.centerYAnchor).isActive = true
+        
+        let request = APIConfiguration(url: url,
+                                       responseBodyObject: ResponseImage.self,
+                                       priority: .high, timeOut: 10)
+        
+        request.request { (result) in
+            DispatchQueue.main.async { [weak self] in
+                guard let self = self else { return }
+                activityIndicator.removeFromSuperview()
+                switch result {
+                case .error(let error):
+                    errorCompletion?(error.error)
+                    if let fallback = fallback {
+                        self.image = fallback
+                    }
+                    completion?(fallback)
+                case .success(let image):
+                    if self.tag == dateTag {
+                        self.image = image.responseBody.image
+                        completion?(image.responseBody.image)
+                    }
+                }
+            }
+        }
+    }
+    
+}
+
+/// Wrapper Class to convert Data to UIImage.
+class ResponseImage: ResponseBodyParsable {
+    
+    static var shouldUseCustomInitializer: Bool { true }
+    /// holds `UIImage` object inside.
+    var image: UIImage
+    
+    required init?(_ data: Data) {
+        guard let image = UIImage(data: data) else {
+            return nil
+        }
+        
+        self.image = image
+    }
+    
+    func encode(to encoder: Encoder) throws {
+        
+    }
+    
+    required init(from decoder: Decoder) throws {
+        self.image = UIImage()
+    }
+    
+    required init?(_ response: Any?) {
+        return nil
+    }
+    
+    func cachingEndsAt() -> Date? {
+        return Date().addingTimeInterval(60 * 60)
+    }
+    
+}
+