Proyectos de Subversion Iphone Microlearning

//
//  UIButton+AlamofireImage.swift
//
//  Copyright (c) 2015 Alamofire Software Foundation (http://alamofire.org/)
//
//  Permission is hereby granted, free of charge, to any person obtaining a copy
//  of this software and associated documentation files (the "Software"), to deal
//  in the Software without restriction, including without limitation the rights
//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//  copies of the Software, and to permit persons to whom the Software is
//  furnished to do so, subject to the following conditions:
//
//  The above copyright notice and this permission notice shall be included in
//  all copies or substantial portions of the Software.
//
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
//  THE SOFTWARE.
//

import Alamofire
import Foundation

#if os(iOS) || os(tvOS)

import UIKit

public typealias ControlState = UIControl.State

extension UIButton: AlamofireExtended {}
extension AlamofireExtension where ExtendedType: UIButton {
    // MARK: - Properties

    /// The instance image downloader used to download all images. If this property is `nil`, the `UIButton` will
    /// fallback on the `sharedImageDownloader` for all downloads. The most common use case for needing to use a
    /// custom instance image downloader is when images are behind different basic auth credentials.
    public var imageDownloader: ImageDownloader? {
        get {
            objc_getAssociatedObject(type, &AssociatedKeys.imageDownloader) as? ImageDownloader
        }
        nonmutating set {
            objc_setAssociatedObject(type, &AssociatedKeys.imageDownloader, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }

    /// The shared image downloader used to download all images. By default, this is the default `ImageDownloader`
    /// instance backed with an `AutoPurgingImageCache` which automatically evicts images from the cache when the memory
    /// capacity is reached or memory warning notifications occur. The shared image downloader is only used if the
    /// `imageDownloader` is `nil`.
    public static var sharedImageDownloader: ImageDownloader {
        get {
            guard let
                downloader = objc_getAssociatedObject(UIButton.self, &AssociatedKeys.sharedImageDownloader) as? ImageDownloader
            else { return ImageDownloader.default }

            return downloader
        }
        set {
            objc_setAssociatedObject(UIButton.self, &AssociatedKeys.sharedImageDownloader, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }

    private var imageRequestReceipts: [UInt: RequestReceipt] {
        get {
            guard let
                receipts = objc_getAssociatedObject(type, &AssociatedKeys.imageReceipts) as? [UInt: RequestReceipt]
            else { return [:] }

            return receipts
        }
        nonmutating set {
            objc_setAssociatedObject(type, &AssociatedKeys.imageReceipts, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }

    private var backgroundImageRequestReceipts: [UInt: RequestReceipt] {
        get {
            guard let
                receipts = objc_getAssociatedObject(type, &AssociatedKeys.backgroundImageReceipts) as? [UInt: RequestReceipt]
            else { return [:] }

            return receipts
        }
        nonmutating set {
            objc_setAssociatedObject(type, &AssociatedKeys.backgroundImageReceipts, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }

    // MARK: - Image Downloads

    /// Asynchronously downloads an image from the specified URL and sets it once the request is finished.
    ///
    /// If the image is cached locally, the image is set immediately. Otherwise the specified placeholder image will be
    /// set immediately, and then the remote image will be set once the image request is finished.
    ///
    /// - parameter state:            The control state of the button to set the image on.
    /// - parameter url:              The URL used for your image request.
    /// - parameter cacheKey:         An optional key used to identify the image in the cache. Defaults to `nil`.
    /// - parameter placeholderImage: The image to be set initially until the image request finished. If `nil`, the
    ///                               image will not change its image until the image request finishes. Defaults
    ///                               to `nil`.
    /// - parameter serializer:       Image response serializer used to convert the image data to `UIImage`. Defaults
    ///                               to `nil` which will fall back to the instance `imageResponseSerializer` set on
    ///                               the `ImageDownloader`.
    /// - parameter filter:           The image filter applied to the image after the image request is finished.
    ///                               Defaults to `nil`.
    /// - parameter progress:         The closure to be executed periodically during the lifecycle of the request.
    ///                               Defaults to `nil`.
    /// - parameter progressQueue:    The dispatch queue to call the progress closure on. Defaults to the main queue.
    /// - parameter completion:       A closure to be executed when the image request finishes. The closure takes a
    ///                               single response value containing either the image or the error that occurred. If
    ///                               the image was returned from the image cache, the response will be `nil`. Defaults
    ///                               to `nil`.
    public func setImage(for state: ControlState,
                         url: URL,
                         cacheKey: String? = nil,
                         placeholderImage: UIImage? = nil,
                         serializer: ImageResponseSerializer? = nil,
                         filter: ImageFilter? = nil,
                         progress: ImageDownloader.ProgressHandler? = nil,
                         progressQueue: DispatchQueue = DispatchQueue.main,
                         completion: ((AFIDataResponse<UIImage>) -> Void)? = nil) {
        setImage(for: state,
                 urlRequest: urlRequest(with: url),
                 cacheKey: cacheKey,
                 placeholderImage: placeholderImage,
                 serializer: serializer,
                 filter: filter,
                 progress: progress,
                 progressQueue: progressQueue,
                 completion: completion)
    }

    /// Asynchronously downloads an image from the specified URL and sets it once the request is finished.
    ///
    /// If the image is cached locally, the image is set immediately. Otherwise the specified placeholder image will be
    /// set immediately, and then the remote image will be set once the image request is finished.
    ///
    /// - parameter state:            The control state of the button to set the image on.
    /// - parameter urlRequest:       The URL request.
    /// - parameter cacheKey:         An optional key used to identify the image in the cache. Defaults to `nil`.
    /// - parameter placeholderImage: The image to be set initially until the image request finished. If `nil`, the
    ///                               image will not change its image until the image request finishes. Defaults
    ///                               to `nil`.
    /// - parameter serializer:       Image response serializer used to convert the image data to `UIImage`. Defaults
    ///                               to `nil` which will fall back to the instance `imageResponseSerializer` set on
    ///                               the `ImageDownloader`.
    /// - parameter filter:           The image filter applied to the image after the image request is finished.
    ///                               Defaults to `nil`.
    /// - parameter progress:         The closure to be executed periodically during the lifecycle of the request.
    ///                               Defaults to `nil`.
    /// - parameter progressQueue:    The dispatch queue to call the progress closure on. Defaults to the main queue.
    /// - parameter completion:       A closure to be executed when the image request finishes. The closure takes a
    ///                               single response value containing either the image or the error that occurred. If
    ///                               the image was returned from the image cache, the response will be `nil`. Defaults
    ///                               to `nil`.
    public func setImage(for state: ControlState,
                         urlRequest: URLRequestConvertible,
                         cacheKey: String? = nil,
                         placeholderImage: UIImage? = nil,
                         serializer: ImageResponseSerializer? = nil,
                         filter: ImageFilter? = nil,
                         progress: ImageDownloader.ProgressHandler? = nil,
                         progressQueue: DispatchQueue = DispatchQueue.main,
                         completion: ((AFIDataResponse<UIImage>) -> Void)? = nil) {
        guard !isImageURLRequest(urlRequest, equalToActiveRequestURLForState: state) else {
            let response = AFIDataResponse<UIImage>(request: nil,
                                                    response: nil,
                                                    data: nil,
                                                    metrics: nil,
                                                    serializationDuration: 0.0,
                                                    result: .failure(AFIError.requestCancelled))

            completion?(response)

            return
        }

        cancelImageRequest(for: state)

        let imageDownloader = self.imageDownloader ?? UIButton.af.sharedImageDownloader
        let imageCache = imageDownloader.imageCache

        // Use the image from the image cache if it exists
        if let request = urlRequest.urlRequest {
            let cachedImage: Image?

            if let cacheKey = cacheKey {
                cachedImage = imageCache?.image(withIdentifier: cacheKey)
            } else {
                cachedImage = imageCache?.image(for: request, withIdentifier: filter?.identifier)
            }

            if let image = cachedImage {
                let response = AFIDataResponse<UIImage>(request: urlRequest.urlRequest,
                                                        response: nil,
                                                        data: nil,
                                                        metrics: nil,
                                                        serializationDuration: 0.0,
                                                        result: .success(image))

                type.setImage(image, for: state)
                completion?(response)

                return
            }
        }

        // Set the placeholder since we're going to have to download
        if let placeholderImage = placeholderImage { type.setImage(placeholderImage, for: state) }

        // Generate a unique download id to check whether the active request has changed while downloading
        let downloadID = UUID().uuidString

        // Weakify the button to allow it to go out-of-memory while download is running if deallocated
        weak var button = type

        // Download the image, then set the image for the control state
        let requestReceipt = imageDownloader.download(urlRequest,
                                                      cacheKey: cacheKey,
                                                      receiptID: downloadID,
                                                      serializer: serializer,
                                                      filter: filter,
                                                      progress: progress,
                                                      progressQueue: progressQueue,
                                                      completion: { response in
                                                          guard
                                                              let strongSelf = button?.af,
                                                              strongSelf.isImageURLRequest(response.request, equalToActiveRequestURLForState: state) &&
                                                              strongSelf.imageRequestReceipt(for: state)?.receiptID == downloadID
                                                          else {
                                                              completion?(response)
                                                              return
                                                          }

                                                          if case let .success(image) = response.result {
                                                              strongSelf.type.setImage(image, for: state)
                                                          }

                                                          strongSelf.setImageRequestReceipt(nil, for: state)

                                                          completion?(response)
                                                      })

        setImageRequestReceipt(requestReceipt, for: state)
    }

    /// Cancels the active download request for the image, if one exists.
    public func cancelImageRequest(for state: ControlState) {
        guard let receipt = imageRequestReceipt(for: state) else { return }

        let imageDownloader = self.imageDownloader ?? UIButton.af.sharedImageDownloader
        imageDownloader.cancelRequest(with: receipt)

        setImageRequestReceipt(nil, for: state)
    }

    // MARK: - Background Image Downloads

    /// Asynchronously downloads an image from the specified URL and sets it once the request is finished.
    ///
    /// If the image is cached locally, the image is set immediately. Otherwise the specified placeholder image will be
    /// set immediately, and then the remote image will be set once the image request is finished.
    ///
    /// - parameter state:            The control state of the button to set the image on.
    /// - parameter url:              The URL used for the image request.
    /// - parameter cacheKey:         An optional key used to identify the image in the cache. Defaults to `nil`.
    /// - parameter placeholderImage: The image to be set initially until the image request finished. If `nil`, the
    ///                               background image will not change its image until the image request finishes.
    ///                               Defaults to `nil`.
    /// - parameter serializer:       Image response serializer used to convert the image data to `UIImage`. Defaults
    ///                               to `nil` which will fall back to the instance `imageResponseSerializer` set on
    ///                               the `ImageDownloader`.
    /// - parameter filter:           The image filter applied to the image after the image request is finished.
    ///                               Defaults to `nil`.
    /// - parameter progress:         The closure to be executed periodically during the lifecycle of the request.
    ///                               Defaults to `nil`.
    /// - parameter progressQueue:    The dispatch queue to call the progress closure on. Defaults to the main queue.
    /// - parameter completion:       A closure to be executed when the image request finishes. The closure takes a
    ///                               single response value containing either the image or the error that occurred. If
    ///                               the image was returned from the image cache, the response will be `nil`. Defaults
    ///                               to `nil`.
    public func setBackgroundImage(for state: ControlState,
                                   url: URL,
                                   cacheKey: String? = nil,
                                   placeholderImage: UIImage? = nil,
                                   serializer: ImageResponseSerializer? = nil,
                                   filter: ImageFilter? = nil,
                                   progress: ImageDownloader.ProgressHandler? = nil,
                                   progressQueue: DispatchQueue = DispatchQueue.main,
                                   completion: ((AFIDataResponse<UIImage>) -> Void)? = nil) {
        setBackgroundImage(for: state,
                           urlRequest: urlRequest(with: url),
                           cacheKey: cacheKey,
                           placeholderImage: placeholderImage,
                           serializer: serializer,
                           filter: filter,
                           progress: progress,
                           progressQueue: progressQueue,
                           completion: completion)
    }

    /// Asynchronously downloads an image from the specified URL request and sets it once the request is finished.
    ///
    /// If the image is cached locally, the image is set immediately. Otherwise the specified placeholder image will be
    /// set immediately, and then the remote image will be set once the image request is finished.
    ///
    /// - parameter state:            The control state of the button to set the image on.
    /// - parameter urlRequest:       The URL request.
    /// - parameter cacheKey:         An optional key used to identify the image in the cache. Defaults to `nil`.
    /// - parameter placeholderImage: The image to be set initially until the image request finished. If `nil`, the
    ///                               background image will not change its image until the image request finishes.
    ///                               Defaults to `nil`.
    /// - parameter serializer:       Image response serializer used to convert the image data to `UIImage`. Defaults
    ///                               to `nil` which will fall back to the instance `imageResponseSerializer` set on
    ///                               the `ImageDownloader`.
    /// - parameter filter:           The image filter applied to the image after the image request is finished.
    ///                               Defaults to `nil`.
    /// - parameter progress:         The closure to be executed periodically during the lifecycle of the request.
    ///                               Defaults to `nil`.
    /// - parameter progressQueue:    The dispatch queue to call the progress closure on. Defaults to the main queue.
    /// - parameter completion:       A closure to be executed when the image request finishes. The closure takes a
    ///                               single response value containing either the image or the error that occurred. If
    ///                               the image was returned from the image cache, the response will be `nil`. Defaults
    ///                               to `nil`.
    public func setBackgroundImage(for state: ControlState,
                                   urlRequest: URLRequestConvertible,
                                   cacheKey: String? = nil,
                                   placeholderImage: UIImage? = nil,
                                   serializer: ImageResponseSerializer? = nil,
                                   filter: ImageFilter? = nil,
                                   progress: ImageDownloader.ProgressHandler? = nil,
                                   progressQueue: DispatchQueue = DispatchQueue.main,
                                   completion: ((AFIDataResponse<UIImage>) -> Void)? = nil) {
        guard !isImageURLRequest(urlRequest, equalToActiveRequestURLForState: state) else {
            let response = AFIDataResponse<UIImage>(request: nil,
                                                    response: nil,
                                                    data: nil,
                                                    metrics: nil,
                                                    serializationDuration: 0.0,
                                                    result: .failure(AFIError.requestCancelled))

            completion?(response)

            return
        }

        cancelBackgroundImageRequest(for: state)

        let imageDownloader = self.imageDownloader ?? UIButton.af.sharedImageDownloader
        let imageCache = imageDownloader.imageCache

        // Use the image from the image cache if it exists
        if let request = urlRequest.urlRequest {
            let cachedImage: Image?

            if let cacheKey = cacheKey {
                cachedImage = imageCache?.image(withIdentifier: cacheKey)
            } else {
                cachedImage = imageCache?.image(for: request, withIdentifier: filter?.identifier)
            }

            if let image = cachedImage {
                let response = AFIDataResponse<UIImage>(request: urlRequest.urlRequest,
                                                        response: nil,
                                                        data: nil,
                                                        metrics: nil,
                                                        serializationDuration: 0.0,
                                                        result: .success(image))

                type.setBackgroundImage(image, for: state)
                completion?(response)

                return
            }
        }

        // Set the placeholder since we're going to have to download
        if let placeholderImage = placeholderImage { type.setBackgroundImage(placeholderImage, for: state) }

        // Generate a unique download id to check whether the active request has changed while downloading
        let downloadID = UUID().uuidString

        // Weakify the button to allow it to go out-of-memory while download is running if deallocated
        weak var button = type

        // Download the image, then set the image for the control state
        let requestReceipt = imageDownloader.download(urlRequest,
                                                      cacheKey: cacheKey,
                                                      receiptID: downloadID,
                                                      serializer: serializer,
                                                      filter: filter,
                                                      progress: progress,
                                                      progressQueue: progressQueue,
                                                      completion: { response in
                                                          guard
                                                              let strongSelf = button?.af,
                                                              strongSelf.isBackgroundImageURLRequest(response.request, equalToActiveRequestURLForState: state) &&
                                                              strongSelf.backgroundImageRequestReceipt(for: state)?.receiptID == downloadID
                                                          else {
                                                              completion?(response)
                                                              return
                                                          }

                                                          if case let .success(image) = response.result {
                                                              strongSelf.type.setBackgroundImage(image, for: state)
                                                          }

                                                          strongSelf.setBackgroundImageRequestReceipt(nil, for: state)

                                                          completion?(response)
                                                      })

        setBackgroundImageRequestReceipt(requestReceipt, for: state)
    }

    /// Cancels the active download request for the background image, if one exists.
    public func cancelBackgroundImageRequest(for state: ControlState) {
        guard let receipt = backgroundImageRequestReceipt(for: state) else { return }

        let imageDownloader = self.imageDownloader ?? UIButton.af.sharedImageDownloader
        imageDownloader.cancelRequest(with: receipt)

        setBackgroundImageRequestReceipt(nil, for: state)
    }

    // MARK: - Internal - Image Request Receipts

    func imageRequestReceipt(for state: ControlState) -> RequestReceipt? {
        guard let receipt = imageRequestReceipts[state.rawValue] else { return nil }
        return receipt
    }

    func setImageRequestReceipt(_ receipt: RequestReceipt?, for state: ControlState) {
        var receipts = imageRequestReceipts
        receipts[state.rawValue] = receipt

        imageRequestReceipts = receipts
    }

    // MARK: - Internal - Background Image Request Receipts

    func backgroundImageRequestReceipt(for state: ControlState) -> RequestReceipt? {
        guard let receipt = backgroundImageRequestReceipts[state.rawValue] else { return nil }
        return receipt
    }

    func setBackgroundImageRequestReceipt(_ receipt: RequestReceipt?, for state: ControlState) {
        var receipts = backgroundImageRequestReceipts
        receipts[state.rawValue] = receipt

        backgroundImageRequestReceipts = receipts
    }

    // MARK: - Private - URL Request Helpers

    private func isImageURLRequest(_ urlRequest: URLRequestConvertible?,
                                   equalToActiveRequestURLForState state: ControlState)
        -> Bool {
        if
            let currentURL = imageRequestReceipt(for: state)?.request.task?.originalRequest?.url,
            let requestURL = urlRequest?.urlRequest?.url,
            currentURL == requestURL {
            return true
        }

        return false
    }

    private func isBackgroundImageURLRequest(_ urlRequest: URLRequestConvertible?,
                                             equalToActiveRequestURLForState state: ControlState)
        -> Bool {
        if
            let currentRequestURL = backgroundImageRequestReceipt(for: state)?.request.task?.originalRequest?.url,
            let requestURL = urlRequest?.urlRequest?.url,
            currentRequestURL == requestURL {
            return true
        }

        return false
    }

    private func urlRequest(with url: URL) -> URLRequest {
        var urlRequest = URLRequest(url: url)

        for mimeType in ImageResponseSerializer.acceptableImageContentTypes.sorted() {
            urlRequest.addValue(mimeType, forHTTPHeaderField: "Accept")
        }

        return urlRequest
    }
}

// MARK: - Deprecated

extension UIButton {
    @available(*, deprecated, message: "Replaced by `button.af.imageDownloader`")
    public var af_imageDownloader: ImageDownloader? {
        get { af.imageDownloader }
        set { af.imageDownloader = newValue }
    }

    @available(*, deprecated, message: "Replaced by `button.af.sharedImageDownloader`")
    public class var af_sharedImageDownloader: ImageDownloader {
        get { af.sharedImageDownloader }
        set { af.sharedImageDownloader = newValue }
    }

    @available(*, deprecated, message: "Replaced by `button.af.sharedImageDownloader`")
    public func af_setImage(for state: ControlState,
                            url: URL,
                            cacheKey: String? = nil,
                            placeholderImage: UIImage? = nil,
                            serializer: ImageResponseSerializer? = nil,
                            filter: ImageFilter? = nil,
                            progress: ImageDownloader.ProgressHandler? = nil,
                            progressQueue: DispatchQueue = DispatchQueue.main,
                            completion: ((AFIDataResponse<UIImage>) -> Void)? = nil) {
        af.setImage(for: state,
                    url: url,
                    cacheKey: cacheKey,
                    placeholderImage: placeholderImage,
                    serializer: serializer,
                    filter: filter,
                    progress: progress,
                    progressQueue: progressQueue,
                    completion: completion)
    }

    @available(*, deprecated, message: "Replaced by `button.af.sharedImageDownloader`")
    public func af_setImage(for state: ControlState,
                            urlRequest: URLRequestConvertible,
                            cacheKey: String? = nil,
                            placeholderImage: UIImage? = nil,
                            serializer: ImageResponseSerializer? = nil,
                            filter: ImageFilter? = nil,
                            progress: ImageDownloader.ProgressHandler? = nil,
                            progressQueue: DispatchQueue = DispatchQueue.main,
                            completion: ((AFIDataResponse<UIImage>) -> Void)? = nil) {
        af.setImage(for: state,
                    urlRequest: urlRequest,
                    cacheKey: cacheKey,
                    placeholderImage: placeholderImage,
                    serializer: serializer,
                    filter: filter,
                    progress: progress,
                    progressQueue: progressQueue,
                    completion: completion)
    }

    /// Cancels the active download request for the image, if one exists.
    public func af_cancelImageRequest(for state: ControlState) {
        af.cancelImageRequest(for: state)
    }

    @available(*, deprecated, message: "Replaced by `button.af.sharedImageDownloader`")
    public func af_setBackgroundImage(for state: ControlState,
                                      url: URL,
                                      cacheKey: String? = nil,
                                      placeholderImage: UIImage? = nil,
                                      serializer: ImageResponseSerializer? = nil,
                                      filter: ImageFilter? = nil,
                                      progress: ImageDownloader.ProgressHandler? = nil,
                                      progressQueue: DispatchQueue = DispatchQueue.main,
                                      completion: ((AFIDataResponse<UIImage>) -> Void)? = nil) {
        af.setBackgroundImage(for: state,
                              url: url,
                              cacheKey: cacheKey,
                              placeholderImage: placeholderImage,
                              serializer: serializer,
                              filter: filter,
                              progress: progress,
                              progressQueue: progressQueue,
                              completion: completion)
    }

    @available(*, deprecated, message: "Replaced by `button.af.sharedImageDownloader`")
    public func af_setBackgroundImage(for state: ControlState,
                                      urlRequest: URLRequestConvertible,
                                      cacheKey: String? = nil,
                                      placeholderImage: UIImage? = nil,
                                      serializer: ImageResponseSerializer? = nil,
                                      filter: ImageFilter? = nil,
                                      progress: ImageDownloader.ProgressHandler? = nil,
                                      progressQueue: DispatchQueue = DispatchQueue.main,
                                      completion: ((AFIDataResponse<UIImage>) -> Void)? = nil) {
        af.setBackgroundImage(for: state,
                              urlRequest: urlRequest,
                              cacheKey: cacheKey,
                              placeholderImage: placeholderImage,
                              serializer: serializer,
                              filter: filter,
                              progress: progress,
                              progressQueue: progressQueue,
                              completion: completion)
    }

    /// Cancels the active download request for the background image, if one exists.
    public func af_cancelBackgroundImageRequest(for state: ControlState) {
        af.cancelBackgroundImageRequest(for: state)
    }
}

// MARK: - Private - AssociatedKeys

private enum AssociatedKeys {
    static var imageDownloader = "UIButton.af.imageDownloader"
    static var sharedImageDownloader = "UIButton.af.sharedImageDownloader"
    static var imageReceipts = "UIButton.af.imageReceipts"
    static var backgroundImageReceipts = "UIButton.af.backgroundImageReceipts"
}

#endif