| // ResponseSerialization.swift |
| // |
| // Copyright (c) 2014–2016 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 Foundation |
| |
| // MARK: ResponseSerializer |
| |
| /** |
| The type in which all response serializers must conform to in order to serialize a response. |
| */ |
| public protocol ResponseSerializerType { |
| /// The type of serialized object to be created by this `ResponseSerializerType`. |
| associatedtype SerializedObject |
| |
| /// The type of error to be created by this `ResponseSerializer` if serialization fails. |
| associatedtype ErrorObject: ErrorType |
| |
| /** |
| A closure used by response handlers that takes a request, response, data and error and returns a result. |
| */ |
| var serializeResponse: (NSURLRequest?, NSHTTPURLResponse?, NSData?, NSError?) -> Result<SerializedObject, ErrorObject> { get } |
| } |
| |
| // MARK: - |
| |
| /** |
| A generic `ResponseSerializerType` used to serialize a request, response, and data into a serialized object. |
| */ |
| public struct ResponseSerializer<Value, Error: ErrorType>: ResponseSerializerType { |
| /// The type of serialized object to be created by this `ResponseSerializer`. |
| public typealias SerializedObject = Value |
| |
| /// The type of error to be created by this `ResponseSerializer` if serialization fails. |
| public typealias ErrorObject = Error |
| |
| /** |
| A closure used by response handlers that takes a request, response, data and error and returns a result. |
| */ |
| public var serializeResponse: (NSURLRequest?, NSHTTPURLResponse?, NSData?, NSError?) -> Result<Value, Error> |
| |
| /** |
| Initializes the `ResponseSerializer` instance with the given serialize response closure. |
| |
| - parameter serializeResponse: The closure used to serialize the response. |
| |
| - returns: The new generic response serializer instance. |
| */ |
| public init(serializeResponse: (NSURLRequest?, NSHTTPURLResponse?, NSData?, NSError?) -> Result<Value, Error>) { |
| self.serializeResponse = serializeResponse |
| } |
| } |
| |
| // MARK: - Default |
| |
| extension Request { |
| |
| /** |
| Adds a handler to be called once the request has finished. |
| |
| - parameter queue: The queue on which the completion handler is dispatched. |
| - parameter completionHandler: The code to be executed once the request has finished. |
| |
| - returns: The request. |
| */ |
| public func response( |
| queue queue: dispatch_queue_t? = nil, |
| completionHandler: (NSURLRequest?, NSHTTPURLResponse?, NSData?, NSError?) -> Void) |
| -> Self |
| { |
| delegate.queue.addOperationWithBlock { |
| dispatch_async(queue ?? dispatch_get_main_queue()) { |
| completionHandler(self.request, self.response, self.delegate.data, self.delegate.error) |
| } |
| } |
| |
| return self |
| } |
| |
| /** |
| Adds a handler to be called once the request has finished. |
| |
| - parameter queue: The queue on which the completion handler is dispatched. |
| - parameter responseSerializer: The response serializer responsible for serializing the request, response, |
| and data. |
| - parameter completionHandler: The code to be executed once the request has finished. |
| |
| - returns: The request. |
| */ |
| public func response<T: ResponseSerializerType>( |
| queue queue: dispatch_queue_t? = nil, |
| responseSerializer: T, |
| completionHandler: Response<T.SerializedObject, T.ErrorObject> -> Void) |
| -> Self |
| { |
| delegate.queue.addOperationWithBlock { |
| let result = responseSerializer.serializeResponse( |
| self.request, |
| self.response, |
| self.delegate.data, |
| self.delegate.error |
| ) |
| |
| let requestCompletedTime = self.endTime ?? CFAbsoluteTimeGetCurrent() |
| let initialResponseTime = self.delegate.initialResponseTime ?? requestCompletedTime |
| |
| let timeline = Timeline( |
| requestStartTime: self.startTime ?? CFAbsoluteTimeGetCurrent(), |
| initialResponseTime: initialResponseTime, |
| requestCompletedTime: requestCompletedTime, |
| serializationCompletedTime: CFAbsoluteTimeGetCurrent() |
| ) |
| |
| let response = Response<T.SerializedObject, T.ErrorObject>( |
| request: self.request, |
| response: self.response, |
| data: self.delegate.data, |
| result: result, |
| timeline: timeline |
| ) |
| |
| dispatch_async(queue ?? dispatch_get_main_queue()) { completionHandler(response) } |
| } |
| |
| return self |
| } |
| } |
| |
| // MARK: - Data |
| |
| extension Request { |
| |
| /** |
| Creates a response serializer that returns the associated data as-is. |
| |
| - returns: A data response serializer. |
| */ |
| public static func dataResponseSerializer() -> ResponseSerializer<NSData, NSError> { |
| return ResponseSerializer { _, response, data, error in |
| guard error == nil else { return .Failure(error!) } |
| |
| if let response = response where response.statusCode == 204 { return .Success(NSData()) } |
| |
| guard let validData = data else { |
| let failureReason = "Data could not be serialized. Input data was nil." |
| let error = Error.errorWithCode(.DataSerializationFailed, failureReason: failureReason) |
| return .Failure(error) |
| } |
| |
| return .Success(validData) |
| } |
| } |
| |
| /** |
| Adds a handler to be called once the request has finished. |
| |
| - parameter completionHandler: The code to be executed once the request has finished. |
| |
| - returns: The request. |
| */ |
| public func responseData( |
| queue queue: dispatch_queue_t? = nil, |
| completionHandler: Response<NSData, NSError> -> Void) |
| -> Self |
| { |
| return response(queue: queue, responseSerializer: Request.dataResponseSerializer(), completionHandler: completionHandler) |
| } |
| } |
| |
| // MARK: - String |
| |
| extension Request { |
| |
| /** |
| Creates a response serializer that returns a string initialized from the response data with the specified |
| string encoding. |
| |
| - parameter encoding: The string encoding. If `nil`, the string encoding will be determined from the server |
| response, falling back to the default HTTP default character set, ISO-8859-1. |
| |
| - returns: A string response serializer. |
| */ |
| public static func stringResponseSerializer( |
| encoding encoding: NSStringEncoding? = nil) |
| -> ResponseSerializer<String, NSError> |
| { |
| return ResponseSerializer { _, response, data, error in |
| guard error == nil else { return .Failure(error!) } |
| |
| if let response = response where response.statusCode == 204 { return .Success("") } |
| |
| guard let validData = data else { |
| let failureReason = "String could not be serialized. Input data was nil." |
| let error = Error.errorWithCode(.StringSerializationFailed, failureReason: failureReason) |
| return .Failure(error) |
| } |
| |
| var convertedEncoding = encoding |
| |
| if let encodingName = response?.textEncodingName where convertedEncoding == nil { |
| convertedEncoding = CFStringConvertEncodingToNSStringEncoding( |
| CFStringConvertIANACharSetNameToEncoding(encodingName) |
| ) |
| } |
| |
| let actualEncoding = convertedEncoding ?? NSISOLatin1StringEncoding |
| |
| if let string = String(data: validData, encoding: actualEncoding) { |
| return .Success(string) |
| } else { |
| let failureReason = "String could not be serialized with encoding: \(actualEncoding)" |
| let error = Error.errorWithCode(.StringSerializationFailed, failureReason: failureReason) |
| return .Failure(error) |
| } |
| } |
| } |
| |
| /** |
| Adds a handler to be called once the request has finished. |
| |
| - parameter encoding: The string encoding. If `nil`, the string encoding will be determined from the |
| server response, falling back to the default HTTP default character set, |
| ISO-8859-1. |
| - parameter completionHandler: A closure to be executed once the request has finished. |
| |
| - returns: The request. |
| */ |
| public func responseString( |
| queue queue: dispatch_queue_t? = nil, |
| encoding: NSStringEncoding? = nil, |
| completionHandler: Response<String, NSError> -> Void) |
| -> Self |
| { |
| return response( |
| queue: queue, |
| responseSerializer: Request.stringResponseSerializer(encoding: encoding), |
| completionHandler: completionHandler |
| ) |
| } |
| } |
| |
| // MARK: - JSON |
| |
| extension Request { |
| |
| /** |
| Creates a response serializer that returns a JSON object constructed from the response data using |
| `NSJSONSerialization` with the specified reading options. |
| |
| - parameter options: The JSON serialization reading options. `.AllowFragments` by default. |
| |
| - returns: A JSON object response serializer. |
| */ |
| public static func JSONResponseSerializer( |
| options options: NSJSONReadingOptions = .AllowFragments) |
| -> ResponseSerializer<AnyObject, NSError> |
| { |
| return ResponseSerializer { _, response, data, error in |
| guard error == nil else { return .Failure(error!) } |
| |
| if let response = response where response.statusCode == 204 { return .Success(NSNull()) } |
| |
| guard let validData = data where validData.length > 0 else { |
| let failureReason = "JSON could not be serialized. Input data was nil or zero length." |
| let error = Error.errorWithCode(.JSONSerializationFailed, failureReason: failureReason) |
| return .Failure(error) |
| } |
| |
| do { |
| let JSON = try NSJSONSerialization.JSONObjectWithData(validData, options: options) |
| return .Success(JSON) |
| } catch { |
| return .Failure(error as NSError) |
| } |
| } |
| } |
| |
| /** |
| Adds a handler to be called once the request has finished. |
| |
| - parameter options: The JSON serialization reading options. `.AllowFragments` by default. |
| - parameter completionHandler: A closure to be executed once the request has finished. |
| |
| - returns: The request. |
| */ |
| public func responseJSON( |
| queue queue: dispatch_queue_t? = nil, |
| options: NSJSONReadingOptions = .AllowFragments, |
| completionHandler: Response<AnyObject, NSError> -> Void) |
| -> Self |
| { |
| return response( |
| queue: queue, |
| responseSerializer: Request.JSONResponseSerializer(options: options), |
| completionHandler: completionHandler |
| ) |
| } |
| } |
| |
| // MARK: - Property List |
| |
| extension Request { |
| |
| /** |
| Creates a response serializer that returns an object constructed from the response data using |
| `NSPropertyListSerialization` with the specified reading options. |
| |
| - parameter options: The property list reading options. `NSPropertyListReadOptions()` by default. |
| |
| - returns: A property list object response serializer. |
| */ |
| public static func propertyListResponseSerializer( |
| options options: NSPropertyListReadOptions = NSPropertyListReadOptions()) |
| -> ResponseSerializer<AnyObject, NSError> |
| { |
| return ResponseSerializer { _, response, data, error in |
| guard error == nil else { return .Failure(error!) } |
| |
| if let response = response where response.statusCode == 204 { return .Success(NSNull()) } |
| |
| guard let validData = data where validData.length > 0 else { |
| let failureReason = "Property list could not be serialized. Input data was nil or zero length." |
| let error = Error.errorWithCode(.PropertyListSerializationFailed, failureReason: failureReason) |
| return .Failure(error) |
| } |
| |
| do { |
| let plist = try NSPropertyListSerialization.propertyListWithData(validData, options: options, format: nil) |
| return .Success(plist) |
| } catch { |
| return .Failure(error as NSError) |
| } |
| } |
| } |
| |
| /** |
| Adds a handler to be called once the request has finished. |
| |
| - parameter options: The property list reading options. `0` by default. |
| - parameter completionHandler: A closure to be executed once the request has finished. The closure takes 3 |
| arguments: the URL request, the URL response, the server data and the result |
| produced while creating the property list. |
| |
| - returns: The request. |
| */ |
| public func responsePropertyList( |
| queue queue: dispatch_queue_t? = nil, |
| options: NSPropertyListReadOptions = NSPropertyListReadOptions(), |
| completionHandler: Response<AnyObject, NSError> -> Void) |
| -> Self |
| { |
| return response( |
| queue: queue, |
| responseSerializer: Request.propertyListResponseSerializer(options: options), |
| completionHandler: completionHandler |
| ) |
| } |
| } |