Alamfire源码

extension Request: Equatable {
    public static func ==(lhs: Request, rhs: Request) -> Bool {
        return lhs.id == rhs.id
    }
}

extension Request: Hashable {
    public func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
}

extension Request: CustomStringConvertible {
    /// A textual representation of this instance, including the `HTTPMethod` and `URL` if the `URLRequest` has been
    /// created, as well as the response status code, if a response has been received.
    public var description: String {
        guard let request = performedRequests.last ?? lastRequest,
            let url = request.url,
            let method = request.httpMethod else { return "No request created yet." }

        let requestDescription = "\(method) \(url.absoluteString)"

        return response.map { "\(requestDescription) (\($0.statusCode))" } ?? requestDescription
    }
}

 /// Type describing the source used to create the underlying `URLSessionDownloadTask`.

  public enum Downloadable {

​    /// Download should be started from the `URLRequest` produced by the associated `URLRequestConvertible` value.

​    case request(URLRequestConvertible)

​    /// Download should be started from the associated resume `Data` value.

​    case resumeData(Data)

  }

/// A type that can produce an `UploadRequest.Uploadable` value.
public protocol UploadableConvertible {
    /// Produces an `UploadRequest.Uploadable` value from the instance.
    ///
    /// - Returns: The `UploadRequest.Uploadable`.
    /// - Throws:  Any `Error` produced during creation.
    func createUploadable() throws -> UploadRequest.Uploadable
}

extension UploadRequest.Uploadable: UploadableConvertible {
    public func createUploadable() throws -> UploadRequest.Uploadable {
        return self
    }
}

/// A type that can be converted to an upload, whether from an `UploadRequest.Uploadable` or `URLRequestConvertible`.
public protocol UploadConvertible: UploadableConvertible & URLRequestConvertible {}

public class Request {
      
    public enum State {
        case initialized //初始化
        case resumed //恢复
        case suspended //挂起
        case cancelled // 取消
        case finished //完成
				func canTransitionTo(_ state: State) -> Bool {
            switch (self, state) {
            case (.initialized, _):
                return true
            case (_, .initialized), (.cancelled, _), (.finished, _):
                return false
            case (.resumed, .cancelled), (.suspended, .cancelled), (.resumed, .suspended), (.suspended, .resumed):
                return true
            case (.suspended, .suspended), (.resumed, .resumed):
                return false
            case (_, .finished):
                return true
            }
        }
    }
  
      // MARK: - Initial State
		  // MARK: - Mutable State
      // MARK: Progress
      // MARK: Redirect Handling
      // MARK: Cached Response Handling
      // MARK: URLCredential
      // MARK: Validators
      // MARK: URLRequests
      // MARK: HTTPURLResponse
      
      // MARK: Tasks
      /// All `URLSessionTask`s created on behalf of the `Request`.
      public var tasks: [URLSessionTask] { return protectedMutableState.directValue.tasks }
      /// First `URLSessionTask` created on behalf of the `Request`.
      public var firstTask: URLSessionTask? { return tasks.first }
      /// Last `URLSessionTask` crated on behalf of the `Request`.
      public var lastTask: URLSessionTask? { return tasks.last }
      /// Current `URLSessionTask` created on behalf of the `Request`.
      public var task: URLSessionTask? { return lastTask }
      
      ///MARK: Metrics
      
      ///MARK: Retry Count
      public var retryCount: Int { return protectedMutableState.directValue.retryCount }
      ///MARK: Error
      public fileprivate(set) var error: AFError? {
        get { return protectedMutableState.directValue.error }
        set { protectedMutableState.write { $0.error = newValue } }
     }
      
     // MARK: - Internal Event API
     // All API must be called from underlyingQueue.(所有的API必须从底层队列调用)      
      
...
}

// MARK: Task Creation
/// - Returns:   The `URLSessionTask` created.
func task(for request: URLRequest, using session: URLSession) -> URLSessionTask {
    fatalError("Subclasses must override.")
}
// MARK: State

    @discardableResult
    public func cancel() -> Self {
        protectedMutableState.write { mutableState in
            guard mutableState.state.canTransitionTo(.cancelled) else { return }

            mutableState.state = .cancelled

            underlyingQueue.async { self.didCancel() }

            guard let task = mutableState.tasks.last, task.state != .completed else {
                underlyingQueue.async { self.finish() }
                return
            }

            // Resume to ensure metrics are gathered.
            task.resume()
            task.cancel()
            underlyingQueue.async { self.didCancelTask(task) }
        }

        return self
    }

    /// Suspends the instance.
    ///
    /// - Returns: The instance.
    @discardableResult
    public func suspend() -> Self {
        protectedMutableState.write { mutableState in
            guard mutableState.state.canTransitionTo(.suspended) else { return }

            mutableState.state = .suspended

            underlyingQueue.async { self.didSuspend() }

            guard let task = mutableState.tasks.last, task.state != .completed else { return }

            task.suspend()
            underlyingQueue.async { self.didSuspendTask(task) }
        }

        return self
    }

    /// Resumes the instance.
    ///
    /// - Returns: The instance.
    @discardableResult
    public func resume() -> Self {
        protectedMutableState.write { mutableState in
            guard mutableState.state.canTransitionTo(.resumed) else { return }

            mutableState.state = .resumed

            underlyingQueue.async { self.didResume() }

            guard let task = mutableState.tasks.last, task.state != .completed else { return }

            task.resume()
            underlyingQueue.async { self.didResumeTask(task) }
        }

        return self
    }

/// Protected `MutableState` value that provides thread-safe access to state values.
   fileprivate let protectedMutableState: Protector<MutableState> = Protector(MutableState())

   /// `State` of the `Request`.
   public var state: State { return protectedMutableState.directValue.state }
   /// Returns whether `state` is `.initialized`.
   public var isInitialized: Bool { return state == .initialized }
   /// Returns whether `state is `.resumed`.
   public var isResumed: Bool { return state == .resumed }
   /// Returns whether `state` is `.suspended`.
   public var isSuspended: Bool { return state == .suspended }
   /// Returns whether `state` is `.cancelled`.
   public var isCancelled: Bool { return state == .cancelled }
   /// Returns whether `state` is `.finished`.
   public var isFinished: Bool { return state == .finished }

/// Protected `MutableState` value that provides thread-safe access to state values.
    fileprivate let protectedMutableState: Protector<MutableState> = Protector(MutableState())

struct MutableState {
    /// State of the `Request`.
    var state: State = .initialized
    /// `ProgressHandler` and `DispatchQueue` provided for upload progress callbacks.
    var uploadProgressHandler: (handler: ProgressHandler, queue: DispatchQueue)?
    /// `ProgressHandler` and `DispatchQueue` provided for download progress callbacks.
    var downloadProgressHandler: (handler: ProgressHandler, queue: DispatchQueue)?
    /// `RedirectHandler` provided for to handle request redirection.
    var redirectHandler: RedirectHandler?
    /// `CachedResponseHandler` provided to handle response caching.
    var cachedResponseHandler: CachedResponseHandler?
    /// Closure called when the `Request` is able to create a cURL description of itself.
    var cURLHandler: ((String) -> Void)?
    /// Response serialization closures that handle response parsing.
    var responseSerializers: [() -> Void] = []
    /// Response serialization completion closures executed once all response serializers are complete.
    var responseSerializerCompletions: [() -> Void] = []
    /// Whether response serializer processing is finished.
    var responseSerializerProcessingFinished = false
    /// `URLCredential` used for authentication challenges.
    var credential: URLCredential?
    /// All `URLRequest`s created by Alamofire on behalf of the `Request`.
    var requests: [URLRequest] = []
    /// All `URLSessionTask`s created by Alamofire on behalf of the `Request`.
    var tasks: [URLSessionTask] = []
    /// All `URLSessionTaskMetrics` values gathered by Alamofire on behalf of the `Request`. Should correspond
    /// exactly the the `tasks` created.
    var metrics: [URLSessionTaskMetrics] = []
    /// Number of times any retriers provided retried the `Request`.
    var retryCount = 0
    /// Final `AFError` for the `Request`, whether from various internal Alamofire calls or as a result of a `task`.
    var error: AFError?
}

/// Final cleanup step executed when the instance finishes response serialization.
    func cleanup() {
        delegate?.cleanup(after: self)
        // No-op: override in subclass
    }

/// DataRequest是Request子类，使用URLSessionDataTask处理内存中下载的Data

public class DataRequest: Request {
  
}

/// `Request` subclass which downloads `Data` to a file on disk using `URLSessionDownloadTask`.

/// DownloadRequest也是Request子类，使用URLSessionDownloadTask处理下载到硬盘中的Data。
public class  DownloadRequest也是Request子类，使用: Request {

}

/// `DataRequest` subclass which handles `Data` upload from memory, file, or stream using `URLSessionUploadTask`.

public class UploadRequest: DataRequest {

  /// Type describing the origin of the upload, whether `Data`, file, or stream.

  public enum Uploadable {

​    /// Upload from the provided `Data` value.

​    case data(Data)

​    /// Upload from the provided file `URL`, as well as a `Bool` determining whether the source file should be

​    /// automatically removed once uploaded.

​    case file(URL, shouldRemove: Bool)

​    /// Upload from the provided `InputStream`.

​    case stream(InputStream)

  }



  // MARK: **Initial State**



  /// The `UploadableConvertible` value used to produce the `Uploadable` value for this instance.

  public let upload: UploadableConvertible



  /// `FileManager` used to perform cleanup tasks, including the removal of multipart form encoded payloads written

  /// to disk.

  public let fileManager: FileManager



  // MARK: **Mutable State**



  /// `Uploadable` value used by the instance.

  public var uploadable: Uploadable?



  /// Creates an `UploadRequest` using the provided parameters.
  ......

/// Result.swift
import Foundation

public enum Result<Value> {
    case success(Value)
    case failure(Error)

    /// Returns `true` if the result is a success, `false` otherwise.
    public var isSuccess: Bool {
        switch self {
        case .success:
            return true
        case .failure:
            return false
        }
    }

    /// Returns `true` if the result is a failure, `false` otherwise.
    public var isFailure: Bool {
        return !isSuccess
    }

    /// Returns the associated value if the result is a success, `nil` otherwise.
    public var value: Value? {
        switch self {
        case .success(let value):
            return value
        case .failure:
            return nil
        }
    }

    /// Returns the associated error value if the result is a failure, `nil` otherwise.
    public var error: Error? {
        switch self {
        case .success:
            return nil
        case .failure(let error):
            return error
        }
    }
}

// MARK: - CustomStringConvertible

extension Result: CustomStringConvertible {
    /// The textual representation used when written to an output stream, which includes whether the result was a
    /// success or failure.
    public var description: String {
        switch self {
        case .success:
            return "SUCCESS"
        case .failure:
            return "FAILURE"
        }
    }
}

// MARK: - CustomDebugStringConvertible

extension Result: CustomDebugStringConvertible {
    /// The debug textual representation used when written to an output stream, which includes whether the result was a
    /// success or failure in addition to the value or error.
    public var debugDescription: String {
        switch self {
        case .success(let value):
            return "SUCCESS: \(value)"
        case .failure(let error):
            return "FAILURE: \(error)"
        }
    }
}

public enum AFError: Error {
    /// The underlying reason the parameter encoding error occurred.
    ///
    /// - missingURL:                 The URL request did not have a URL to encode.
    /// - jsonEncodingFailed:         JSON serialization failed with an underlying system error during the
    ///                               encoding process.
    /// - propertyListEncodingFailed: Property list serialization failed with an underlying system error during
    ///                               encoding process.
    public enum ParameterEncodingFailureReason {
        case missingURL
        case jsonEncodingFailed(error: Error)
        case propertyListEncodingFailed(error: Error)
    }

    /// The underlying reason the multipart encoding error occurred.
    public enum MultipartEncodingFailureReason {
        case bodyPartURLInvalid(url: URL)
        case bodyPartFilenameInvalid(in: URL)
        case bodyPartFileNotReachable(at: URL)
        case bodyPartFileNotReachableWithError(atURL: URL, error: Error)
        case bodyPartFileIsDirectory(at: URL)
        case bodyPartFileSizeNotAvailable(at: URL)
        case bodyPartFileSizeQueryFailedWithError(forURL: URL, error: Error)
        case bodyPartInputStreamCreationFailed(for: URL)

        case outputStreamCreationFailed(for: URL)
        case outputStreamFileAlreadyExists(at: URL)
        case outputStreamURLInvalid(url: URL)
        case outputStreamWriteFailed(error: Error)

        case inputStreamReadFailed(error: Error)
    }
    public enum ResponseValidationFailureReason {
        case dataFileNil
        case dataFileReadFailed(at: URL)
        case missingContentType(acceptableContentTypes: [String])
        case unacceptableContentType(acceptableContentTypes: [String], responseContentType: String)
        case unacceptableStatusCode(code: Int)
    }
    public enum ResponseSerializationFailureReason {
        case inputDataNil
        case inputDataNilOrZeroLength
        case inputFileNil
        case inputFileReadFailed(at: URL)
        case stringSerializationFailed(encoding: String.Encoding)
        case jsonSerializationFailed(error: Error)
        case propertyListSerializationFailed(error: Error)
    }

    case invalidURL(url: URLConvertible)
    case parameterEncodingFailed(reason: ParameterEncodingFailureReason)
    case multipartEncodingFailed(reason: MultipartEncodingFailureReason)
    case responseValidationFailed(reason: ResponseValidationFailureReason)
    case responseSerializationFailed(reason: ResponseSerializationFailureReason)
}

class JSONSerialization : NSObject