893 lines
37 KiB
Swift
893 lines
37 KiB
Swift
//
|
|
// SessionManager.swift
|
|
//
|
|
// Copyright (c) 2014-2017 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
|
|
|
|
/// Responsible for creating and managing `Request` objects, as well as their underlying `NSURLSession`.
|
|
open class SessionManager {
|
|
|
|
// MARK: - Helper Types
|
|
|
|
/// Defines whether the `MultipartFormData` encoding was successful and contains result of the encoding as
|
|
/// associated values.
|
|
///
|
|
/// - Success: Represents a successful `MultipartFormData` encoding and contains the new `UploadRequest` along with
|
|
/// streaming information.
|
|
/// - Failure: Used to represent a failure in the `MultipartFormData` encoding and also contains the encoding
|
|
/// error.
|
|
public enum MultipartFormDataEncodingResult {
|
|
case success(request: UploadRequest, streamingFromDisk: Bool, streamFileURL: URL?)
|
|
case failure(Error)
|
|
}
|
|
|
|
// MARK: - Properties
|
|
|
|
/// A default instance of `SessionManager`, used by top-level Alamofire request methods, and suitable for use
|
|
/// directly for any ad hoc requests.
|
|
open static let `default`: SessionManager = {
|
|
let configuration = URLSessionConfiguration.default
|
|
configuration.httpAdditionalHeaders = SessionManager.defaultHTTPHeaders
|
|
|
|
return SessionManager(configuration: configuration)
|
|
}()
|
|
|
|
/// Creates default values for the "Accept-Encoding", "Accept-Language" and "User-Agent" headers.
|
|
open static let defaultHTTPHeaders: HTTPHeaders = {
|
|
// Accept-Encoding HTTP Header; see https://tools.ietf.org/html/rfc7230#section-4.2.3
|
|
let acceptEncoding: String = "gzip;q=1.0, compress;q=0.5"
|
|
|
|
// Accept-Language HTTP Header; see https://tools.ietf.org/html/rfc7231#section-5.3.5
|
|
let acceptLanguage = Locale.preferredLanguages.prefix(6).enumerated().map { index, languageCode in
|
|
let quality = 1.0 - (Double(index) * 0.1)
|
|
return "\(languageCode);q=\(quality)"
|
|
}.joined(separator: ", ")
|
|
|
|
// User-Agent Header; see https://tools.ietf.org/html/rfc7231#section-5.5.3
|
|
// Example: `iOS Example/1.0 (org.alamofire.iOS-Example; build:1; iOS 10.0.0) Alamofire/4.0.0`
|
|
let userAgent: String = {
|
|
if let info = Bundle.main.infoDictionary {
|
|
let executable = info[kCFBundleExecutableKey as String] as? String ?? "Unknown"
|
|
let bundle = info[kCFBundleIdentifierKey as String] as? String ?? "Unknown"
|
|
let appVersion = info["CFBundleShortVersionString"] as? String ?? "Unknown"
|
|
let appBuild = info[kCFBundleVersionKey as String] as? String ?? "Unknown"
|
|
|
|
let osNameVersion: String = {
|
|
let version = ProcessInfo.processInfo.operatingSystemVersion
|
|
let versionString = "\(version.majorVersion).\(version.minorVersion).\(version.patchVersion)"
|
|
|
|
let osName: String = {
|
|
#if os(iOS)
|
|
return "iOS"
|
|
#elseif os(watchOS)
|
|
return "watchOS"
|
|
#elseif os(tvOS)
|
|
return "tvOS"
|
|
#elseif os(macOS)
|
|
return "OS X"
|
|
#elseif os(Linux)
|
|
return "Linux"
|
|
#else
|
|
return "Unknown"
|
|
#endif
|
|
}()
|
|
|
|
return "\(osName) \(versionString)"
|
|
}()
|
|
|
|
let alamofireVersion: String = {
|
|
guard
|
|
let afInfo = Bundle(for: SessionManager.self).infoDictionary,
|
|
let build = afInfo["CFBundleShortVersionString"]
|
|
else { return "Unknown" }
|
|
|
|
return "Alamofire/\(build)"
|
|
}()
|
|
|
|
return "\(executable)/\(appVersion) (\(bundle); build:\(appBuild); \(osNameVersion)) \(alamofireVersion)"
|
|
}
|
|
|
|
return "Alamofire"
|
|
}()
|
|
|
|
return [
|
|
"Accept-Encoding": acceptEncoding,
|
|
"Accept-Language": acceptLanguage,
|
|
"User-Agent": userAgent
|
|
]
|
|
}()
|
|
|
|
/// Default memory threshold used when encoding `MultipartFormData` in bytes.
|
|
open static let multipartFormDataEncodingMemoryThreshold: UInt64 = 10_000_000
|
|
|
|
/// The underlying session.
|
|
open let session: URLSession
|
|
|
|
/// The session delegate handling all the task and session delegate callbacks.
|
|
open let delegate: SessionDelegate
|
|
|
|
/// Whether to start requests immediately after being constructed. `true` by default.
|
|
open var startRequestsImmediately: Bool = true
|
|
|
|
/// The request adapter called each time a new request is created.
|
|
open var adapter: RequestAdapter?
|
|
|
|
/// The request retrier called each time a request encounters an error to determine whether to retry the request.
|
|
open var retrier: RequestRetrier? {
|
|
get { return delegate.retrier }
|
|
set { delegate.retrier = newValue }
|
|
}
|
|
|
|
/// The background completion handler closure provided by the UIApplicationDelegate
|
|
/// `application:handleEventsForBackgroundURLSession:completionHandler:` method. By setting the background
|
|
/// completion handler, the SessionDelegate `sessionDidFinishEventsForBackgroundURLSession` closure implementation
|
|
/// will automatically call the handler.
|
|
///
|
|
/// If you need to handle your own events before the handler is called, then you need to override the
|
|
/// SessionDelegate `sessionDidFinishEventsForBackgroundURLSession` and manually call the handler when finished.
|
|
///
|
|
/// `nil` by default.
|
|
open var backgroundCompletionHandler: (() -> Void)?
|
|
|
|
let queue = DispatchQueue(label: "org.alamofire.session-manager." + UUID().uuidString)
|
|
|
|
// MARK: - Lifecycle
|
|
|
|
/// Creates an instance with the specified `configuration`, `delegate` and `serverTrustPolicyManager`.
|
|
///
|
|
/// - parameter configuration: The configuration used to construct the managed session.
|
|
/// `URLSessionConfiguration.default` by default.
|
|
/// - parameter delegate: The delegate used when initializing the session. `SessionDelegate()` by
|
|
/// default.
|
|
/// - parameter serverTrustPolicyManager: The server trust policy manager to use for evaluating all server trust
|
|
/// challenges. `nil` by default.
|
|
///
|
|
/// - returns: The new `SessionManager` instance.
|
|
public init(
|
|
configuration: URLSessionConfiguration = URLSessionConfiguration.default,
|
|
delegate: SessionDelegate = SessionDelegate(),
|
|
serverTrustPolicyManager: ServerTrustPolicyManager? = nil)
|
|
{
|
|
self.delegate = delegate
|
|
self.session = URLSession(configuration: configuration, delegate: delegate, delegateQueue: nil)
|
|
|
|
commonInit(serverTrustPolicyManager: serverTrustPolicyManager)
|
|
}
|
|
|
|
/// Creates an instance with the specified `session`, `delegate` and `serverTrustPolicyManager`.
|
|
///
|
|
/// - parameter session: The URL session.
|
|
/// - parameter delegate: The delegate of the URL session. Must equal the URL session's delegate.
|
|
/// - parameter serverTrustPolicyManager: The server trust policy manager to use for evaluating all server trust
|
|
/// challenges. `nil` by default.
|
|
///
|
|
/// - returns: The new `SessionManager` instance if the URL session's delegate matches; `nil` otherwise.
|
|
public init?(
|
|
session: URLSession,
|
|
delegate: SessionDelegate,
|
|
serverTrustPolicyManager: ServerTrustPolicyManager? = nil)
|
|
{
|
|
guard delegate === session.delegate else { return nil }
|
|
|
|
self.delegate = delegate
|
|
self.session = session
|
|
|
|
commonInit(serverTrustPolicyManager: serverTrustPolicyManager)
|
|
}
|
|
|
|
private func commonInit(serverTrustPolicyManager: ServerTrustPolicyManager?) {
|
|
session.serverTrustPolicyManager = serverTrustPolicyManager
|
|
|
|
delegate.sessionManager = self
|
|
|
|
delegate.sessionDidFinishEventsForBackgroundURLSession = { [weak self] session in
|
|
guard let strongSelf = self else { return }
|
|
DispatchQueue.main.async { strongSelf.backgroundCompletionHandler?() }
|
|
}
|
|
}
|
|
|
|
deinit {
|
|
session.invalidateAndCancel()
|
|
}
|
|
|
|
// MARK: - Data Request
|
|
|
|
/// Creates a `DataRequest` to retrieve the contents of the specified `url`, `method`, `parameters`, `encoding`
|
|
/// and `headers`.
|
|
///
|
|
/// - parameter url: The URL.
|
|
/// - parameter method: The HTTP method. `.get` by default.
|
|
/// - parameter parameters: The parameters. `nil` by default.
|
|
/// - parameter encoding: The parameter encoding. `URLEncoding.default` by default.
|
|
/// - parameter headers: The HTTP headers. `nil` by default.
|
|
///
|
|
/// - returns: The created `DataRequest`.
|
|
@discardableResult
|
|
open func request(
|
|
_ url: URLConvertible,
|
|
method: HTTPMethod = .get,
|
|
parameters: Parameters? = nil,
|
|
encoding: ParameterEncoding = URLEncoding.default,
|
|
headers: HTTPHeaders? = nil)
|
|
-> DataRequest
|
|
{
|
|
var originalRequest: URLRequest?
|
|
|
|
do {
|
|
originalRequest = try URLRequest(url: url, method: method, headers: headers)
|
|
let encodedURLRequest = try encoding.encode(originalRequest!, with: parameters)
|
|
return request(encodedURLRequest)
|
|
} catch {
|
|
return request(originalRequest, failedWith: error)
|
|
}
|
|
}
|
|
|
|
/// Creates a `DataRequest` to retrieve the contents of a URL based on the specified `urlRequest`.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// - parameter urlRequest: The URL request.
|
|
///
|
|
/// - returns: The created `DataRequest`.
|
|
@discardableResult
|
|
open func request(_ urlRequest: URLRequestConvertible) -> DataRequest {
|
|
var originalRequest: URLRequest?
|
|
|
|
do {
|
|
originalRequest = try urlRequest.asURLRequest()
|
|
let originalTask = DataRequest.Requestable(urlRequest: originalRequest!)
|
|
|
|
let task = try originalTask.task(session: session, adapter: adapter, queue: queue)
|
|
let request = DataRequest(session: session, requestTask: .data(originalTask, task))
|
|
|
|
delegate[task] = request
|
|
|
|
if startRequestsImmediately { request.resume() }
|
|
|
|
return request
|
|
} catch {
|
|
return request(originalRequest, failedWith: error)
|
|
}
|
|
}
|
|
|
|
// MARK: Private - Request Implementation
|
|
|
|
private func request(_ urlRequest: URLRequest?, failedWith error: Error) -> DataRequest {
|
|
var requestTask: Request.RequestTask = .data(nil, nil)
|
|
|
|
if let urlRequest = urlRequest {
|
|
let originalTask = DataRequest.Requestable(urlRequest: urlRequest)
|
|
requestTask = .data(originalTask, nil)
|
|
}
|
|
|
|
let underlyingError = error.underlyingAdaptError ?? error
|
|
let request = DataRequest(session: session, requestTask: requestTask, error: underlyingError)
|
|
|
|
if let retrier = retrier, error is AdaptError {
|
|
allowRetrier(retrier, toRetry: request, with: underlyingError)
|
|
} else {
|
|
if startRequestsImmediately { request.resume() }
|
|
}
|
|
|
|
return request
|
|
}
|
|
|
|
// MARK: - Download Request
|
|
|
|
// MARK: URL Request
|
|
|
|
/// Creates a `DownloadRequest` to retrieve the contents the specified `url`, `method`, `parameters`, `encoding`,
|
|
/// `headers` and save them to the `destination`.
|
|
///
|
|
/// If `destination` is not specified, the contents will remain in the temporary location determined by the
|
|
/// underlying URL session.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// - parameter url: The URL.
|
|
/// - parameter method: The HTTP method. `.get` by default.
|
|
/// - parameter parameters: The parameters. `nil` by default.
|
|
/// - parameter encoding: The parameter encoding. `URLEncoding.default` by default.
|
|
/// - parameter headers: The HTTP headers. `nil` by default.
|
|
/// - parameter destination: The closure used to determine the destination of the downloaded file. `nil` by default.
|
|
///
|
|
/// - returns: The created `DownloadRequest`.
|
|
@discardableResult
|
|
open func download(
|
|
_ url: URLConvertible,
|
|
method: HTTPMethod = .get,
|
|
parameters: Parameters? = nil,
|
|
encoding: ParameterEncoding = URLEncoding.default,
|
|
headers: HTTPHeaders? = nil,
|
|
to destination: DownloadRequest.DownloadFileDestination? = nil)
|
|
-> DownloadRequest
|
|
{
|
|
do {
|
|
let urlRequest = try URLRequest(url: url, method: method, headers: headers)
|
|
let encodedURLRequest = try encoding.encode(urlRequest, with: parameters)
|
|
return download(encodedURLRequest, to: destination)
|
|
} catch {
|
|
return download(nil, to: destination, failedWith: error)
|
|
}
|
|
}
|
|
|
|
/// Creates a `DownloadRequest` to retrieve the contents of a URL based on the specified `urlRequest` and save
|
|
/// them to the `destination`.
|
|
///
|
|
/// If `destination` is not specified, the contents will remain in the temporary location determined by the
|
|
/// underlying URL session.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// - parameter urlRequest: The URL request
|
|
/// - parameter destination: The closure used to determine the destination of the downloaded file. `nil` by default.
|
|
///
|
|
/// - returns: The created `DownloadRequest`.
|
|
@discardableResult
|
|
open func download(
|
|
_ urlRequest: URLRequestConvertible,
|
|
to destination: DownloadRequest.DownloadFileDestination? = nil)
|
|
-> DownloadRequest
|
|
{
|
|
do {
|
|
let urlRequest = try urlRequest.asURLRequest()
|
|
return download(.request(urlRequest), to: destination)
|
|
} catch {
|
|
return download(nil, to: destination, failedWith: error)
|
|
}
|
|
}
|
|
|
|
// MARK: Resume Data
|
|
|
|
/// Creates a `DownloadRequest` from the `resumeData` produced from a previous request cancellation to retrieve
|
|
/// the contents of the original request and save them to the `destination`.
|
|
///
|
|
/// If `destination` is not specified, the contents will remain in the temporary location determined by the
|
|
/// underlying URL session.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// On the latest release of all the Apple platforms (iOS 10, macOS 10.12, tvOS 10, watchOS 3), `resumeData` is broken
|
|
/// on background URL session configurations. There's an underlying bug in the `resumeData` generation logic where the
|
|
/// data is written incorrectly and will always fail to resume the download. For more information about the bug and
|
|
/// possible workarounds, please refer to the following Stack Overflow post:
|
|
///
|
|
/// - http://stackoverflow.com/a/39347461/1342462
|
|
///
|
|
/// - parameter resumeData: The resume data. This is an opaque data blob produced by `URLSessionDownloadTask`
|
|
/// when a task is cancelled. See `URLSession -downloadTask(withResumeData:)` for
|
|
/// additional information.
|
|
/// - parameter destination: The closure used to determine the destination of the downloaded file. `nil` by default.
|
|
///
|
|
/// - returns: The created `DownloadRequest`.
|
|
@discardableResult
|
|
open func download(
|
|
resumingWith resumeData: Data,
|
|
to destination: DownloadRequest.DownloadFileDestination? = nil)
|
|
-> DownloadRequest
|
|
{
|
|
return download(.resumeData(resumeData), to: destination)
|
|
}
|
|
|
|
// MARK: Private - Download Implementation
|
|
|
|
private func download(
|
|
_ downloadable: DownloadRequest.Downloadable,
|
|
to destination: DownloadRequest.DownloadFileDestination?)
|
|
-> DownloadRequest
|
|
{
|
|
do {
|
|
let task = try downloadable.task(session: session, adapter: adapter, queue: queue)
|
|
let download = DownloadRequest(session: session, requestTask: .download(downloadable, task))
|
|
|
|
download.downloadDelegate.destination = destination
|
|
|
|
delegate[task] = download
|
|
|
|
if startRequestsImmediately { download.resume() }
|
|
|
|
return download
|
|
} catch {
|
|
return download(downloadable, to: destination, failedWith: error)
|
|
}
|
|
}
|
|
|
|
private func download(
|
|
_ downloadable: DownloadRequest.Downloadable?,
|
|
to destination: DownloadRequest.DownloadFileDestination?,
|
|
failedWith error: Error)
|
|
-> DownloadRequest
|
|
{
|
|
var downloadTask: Request.RequestTask = .download(nil, nil)
|
|
|
|
if let downloadable = downloadable {
|
|
downloadTask = .download(downloadable, nil)
|
|
}
|
|
|
|
let underlyingError = error.underlyingAdaptError ?? error
|
|
|
|
let download = DownloadRequest(session: session, requestTask: downloadTask, error: underlyingError)
|
|
download.downloadDelegate.destination = destination
|
|
|
|
if let retrier = retrier, error is AdaptError {
|
|
allowRetrier(retrier, toRetry: download, with: underlyingError)
|
|
} else {
|
|
if startRequestsImmediately { download.resume() }
|
|
}
|
|
|
|
return download
|
|
}
|
|
|
|
// MARK: - Upload Request
|
|
|
|
// MARK: File
|
|
|
|
/// Creates an `UploadRequest` from the specified `url`, `method` and `headers` for uploading the `file`.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// - parameter file: The file to upload.
|
|
/// - parameter url: The URL.
|
|
/// - parameter method: The HTTP method. `.post` by default.
|
|
/// - parameter headers: The HTTP headers. `nil` by default.
|
|
///
|
|
/// - returns: The created `UploadRequest`.
|
|
@discardableResult
|
|
open func upload(
|
|
_ fileURL: URL,
|
|
to url: URLConvertible,
|
|
method: HTTPMethod = .post,
|
|
headers: HTTPHeaders? = nil)
|
|
-> UploadRequest
|
|
{
|
|
do {
|
|
let urlRequest = try URLRequest(url: url, method: method, headers: headers)
|
|
return upload(fileURL, with: urlRequest)
|
|
} catch {
|
|
return upload(nil, failedWith: error)
|
|
}
|
|
}
|
|
|
|
/// Creates a `UploadRequest` from the specified `urlRequest` for uploading the `file`.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// - parameter file: The file to upload.
|
|
/// - parameter urlRequest: The URL request.
|
|
///
|
|
/// - returns: The created `UploadRequest`.
|
|
@discardableResult
|
|
open func upload(_ fileURL: URL, with urlRequest: URLRequestConvertible) -> UploadRequest {
|
|
do {
|
|
let urlRequest = try urlRequest.asURLRequest()
|
|
return upload(.file(fileURL, urlRequest))
|
|
} catch {
|
|
return upload(nil, failedWith: error)
|
|
}
|
|
}
|
|
|
|
// MARK: Data
|
|
|
|
/// Creates an `UploadRequest` from the specified `url`, `method` and `headers` for uploading the `data`.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// - parameter data: The data to upload.
|
|
/// - parameter url: The URL.
|
|
/// - parameter method: The HTTP method. `.post` by default.
|
|
/// - parameter headers: The HTTP headers. `nil` by default.
|
|
///
|
|
/// - returns: The created `UploadRequest`.
|
|
@discardableResult
|
|
open func upload(
|
|
_ data: Data,
|
|
to url: URLConvertible,
|
|
method: HTTPMethod = .post,
|
|
headers: HTTPHeaders? = nil)
|
|
-> UploadRequest
|
|
{
|
|
do {
|
|
let urlRequest = try URLRequest(url: url, method: method, headers: headers)
|
|
return upload(data, with: urlRequest)
|
|
} catch {
|
|
return upload(nil, failedWith: error)
|
|
}
|
|
}
|
|
|
|
/// Creates an `UploadRequest` from the specified `urlRequest` for uploading the `data`.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// - parameter data: The data to upload.
|
|
/// - parameter urlRequest: The URL request.
|
|
///
|
|
/// - returns: The created `UploadRequest`.
|
|
@discardableResult
|
|
open func upload(_ data: Data, with urlRequest: URLRequestConvertible) -> UploadRequest {
|
|
do {
|
|
let urlRequest = try urlRequest.asURLRequest()
|
|
return upload(.data(data, urlRequest))
|
|
} catch {
|
|
return upload(nil, failedWith: error)
|
|
}
|
|
}
|
|
|
|
// MARK: InputStream
|
|
|
|
/// Creates an `UploadRequest` from the specified `url`, `method` and `headers` for uploading the `stream`.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// - parameter stream: The stream to upload.
|
|
/// - parameter url: The URL.
|
|
/// - parameter method: The HTTP method. `.post` by default.
|
|
/// - parameter headers: The HTTP headers. `nil` by default.
|
|
///
|
|
/// - returns: The created `UploadRequest`.
|
|
@discardableResult
|
|
open func upload(
|
|
_ stream: InputStream,
|
|
to url: URLConvertible,
|
|
method: HTTPMethod = .post,
|
|
headers: HTTPHeaders? = nil)
|
|
-> UploadRequest
|
|
{
|
|
do {
|
|
let urlRequest = try URLRequest(url: url, method: method, headers: headers)
|
|
return upload(stream, with: urlRequest)
|
|
} catch {
|
|
return upload(nil, failedWith: error)
|
|
}
|
|
}
|
|
|
|
/// Creates an `UploadRequest` from the specified `urlRequest` for uploading the `stream`.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// - parameter stream: The stream to upload.
|
|
/// - parameter urlRequest: The URL request.
|
|
///
|
|
/// - returns: The created `UploadRequest`.
|
|
@discardableResult
|
|
open func upload(_ stream: InputStream, with urlRequest: URLRequestConvertible) -> UploadRequest {
|
|
do {
|
|
let urlRequest = try urlRequest.asURLRequest()
|
|
return upload(.stream(stream, urlRequest))
|
|
} catch {
|
|
return upload(nil, failedWith: error)
|
|
}
|
|
}
|
|
|
|
// MARK: MultipartFormData
|
|
|
|
/// Encodes `multipartFormData` using `encodingMemoryThreshold` and calls `encodingCompletion` with new
|
|
/// `UploadRequest` using the `url`, `method` and `headers`.
|
|
///
|
|
/// It is important to understand the memory implications of uploading `MultipartFormData`. If the cummulative
|
|
/// payload is small, encoding the data in-memory and directly uploading to a server is the by far the most
|
|
/// efficient approach. However, if the payload is too large, encoding the data in-memory could cause your app to
|
|
/// be terminated. Larger payloads must first be written to disk using input and output streams to keep the memory
|
|
/// footprint low, then the data can be uploaded as a stream from the resulting file. Streaming from disk MUST be
|
|
/// used for larger payloads such as video content.
|
|
///
|
|
/// The `encodingMemoryThreshold` parameter allows Alamofire to automatically determine whether to encode in-memory
|
|
/// or stream from disk. If the content length of the `MultipartFormData` is below the `encodingMemoryThreshold`,
|
|
/// encoding takes place in-memory. If the content length exceeds the threshold, the data is streamed to disk
|
|
/// during the encoding process. Then the result is uploaded as data or as a stream depending on which encoding
|
|
/// technique was used.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// - parameter multipartFormData: The closure used to append body parts to the `MultipartFormData`.
|
|
/// - parameter encodingMemoryThreshold: The encoding memory threshold in bytes.
|
|
/// `multipartFormDataEncodingMemoryThreshold` by default.
|
|
/// - parameter url: The URL.
|
|
/// - parameter method: The HTTP method. `.post` by default.
|
|
/// - parameter headers: The HTTP headers. `nil` by default.
|
|
/// - parameter encodingCompletion: The closure called when the `MultipartFormData` encoding is complete.
|
|
open func upload(
|
|
multipartFormData: @escaping (MultipartFormData) -> Void,
|
|
usingThreshold encodingMemoryThreshold: UInt64 = SessionManager.multipartFormDataEncodingMemoryThreshold,
|
|
to url: URLConvertible,
|
|
method: HTTPMethod = .post,
|
|
headers: HTTPHeaders? = nil,
|
|
encodingCompletion: ((MultipartFormDataEncodingResult) -> Void)?)
|
|
{
|
|
do {
|
|
let urlRequest = try URLRequest(url: url, method: method, headers: headers)
|
|
|
|
return upload(
|
|
multipartFormData: multipartFormData,
|
|
usingThreshold: encodingMemoryThreshold,
|
|
with: urlRequest,
|
|
encodingCompletion: encodingCompletion
|
|
)
|
|
} catch {
|
|
DispatchQueue.main.async { encodingCompletion?(.failure(error)) }
|
|
}
|
|
}
|
|
|
|
/// Encodes `multipartFormData` using `encodingMemoryThreshold` and calls `encodingCompletion` with new
|
|
/// `UploadRequest` using the `urlRequest`.
|
|
///
|
|
/// It is important to understand the memory implications of uploading `MultipartFormData`. If the cummulative
|
|
/// payload is small, encoding the data in-memory and directly uploading to a server is the by far the most
|
|
/// efficient approach. However, if the payload is too large, encoding the data in-memory could cause your app to
|
|
/// be terminated. Larger payloads must first be written to disk using input and output streams to keep the memory
|
|
/// footprint low, then the data can be uploaded as a stream from the resulting file. Streaming from disk MUST be
|
|
/// used for larger payloads such as video content.
|
|
///
|
|
/// The `encodingMemoryThreshold` parameter allows Alamofire to automatically determine whether to encode in-memory
|
|
/// or stream from disk. If the content length of the `MultipartFormData` is below the `encodingMemoryThreshold`,
|
|
/// encoding takes place in-memory. If the content length exceeds the threshold, the data is streamed to disk
|
|
/// during the encoding process. Then the result is uploaded as data or as a stream depending on which encoding
|
|
/// technique was used.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// - parameter multipartFormData: The closure used to append body parts to the `MultipartFormData`.
|
|
/// - parameter encodingMemoryThreshold: The encoding memory threshold in bytes.
|
|
/// `multipartFormDataEncodingMemoryThreshold` by default.
|
|
/// - parameter urlRequest: The URL request.
|
|
/// - parameter encodingCompletion: The closure called when the `MultipartFormData` encoding is complete.
|
|
open func upload(
|
|
multipartFormData: @escaping (MultipartFormData) -> Void,
|
|
usingThreshold encodingMemoryThreshold: UInt64 = SessionManager.multipartFormDataEncodingMemoryThreshold,
|
|
with urlRequest: URLRequestConvertible,
|
|
encodingCompletion: ((MultipartFormDataEncodingResult) -> Void)?)
|
|
{
|
|
DispatchQueue.global(qos: .utility).async {
|
|
let formData = MultipartFormData()
|
|
multipartFormData(formData)
|
|
|
|
var tempFileURL: URL?
|
|
|
|
do {
|
|
var urlRequestWithContentType = try urlRequest.asURLRequest()
|
|
urlRequestWithContentType.setValue(formData.contentType, forHTTPHeaderField: "Content-Type")
|
|
|
|
let isBackgroundSession = self.session.configuration.identifier != nil
|
|
|
|
if formData.contentLength < encodingMemoryThreshold && !isBackgroundSession {
|
|
let data = try formData.encode()
|
|
|
|
let encodingResult = MultipartFormDataEncodingResult.success(
|
|
request: self.upload(data, with: urlRequestWithContentType),
|
|
streamingFromDisk: false,
|
|
streamFileURL: nil
|
|
)
|
|
|
|
DispatchQueue.main.async { encodingCompletion?(encodingResult) }
|
|
} else {
|
|
let fileManager = FileManager.default
|
|
let tempDirectoryURL = URL(fileURLWithPath: NSTemporaryDirectory())
|
|
let directoryURL = tempDirectoryURL.appendingPathComponent("org.alamofire.manager/multipart.form.data")
|
|
let fileName = UUID().uuidString
|
|
let fileURL = directoryURL.appendingPathComponent(fileName)
|
|
|
|
tempFileURL = fileURL
|
|
|
|
var directoryError: Error?
|
|
|
|
// Create directory inside serial queue to ensure two threads don't do this in parallel
|
|
self.queue.sync {
|
|
do {
|
|
try fileManager.createDirectory(at: directoryURL, withIntermediateDirectories: true, attributes: nil)
|
|
} catch {
|
|
directoryError = error
|
|
}
|
|
}
|
|
|
|
if let directoryError = directoryError { throw directoryError }
|
|
|
|
try formData.writeEncodedData(to: fileURL)
|
|
|
|
let upload = self.upload(fileURL, with: urlRequestWithContentType)
|
|
|
|
// Cleanup the temp file once the upload is complete
|
|
upload.delegate.queue.addOperation {
|
|
do {
|
|
try FileManager.default.removeItem(at: fileURL)
|
|
} catch {
|
|
// No-op
|
|
}
|
|
}
|
|
|
|
DispatchQueue.main.async {
|
|
let encodingResult = MultipartFormDataEncodingResult.success(
|
|
request: upload,
|
|
streamingFromDisk: true,
|
|
streamFileURL: fileURL
|
|
)
|
|
|
|
encodingCompletion?(encodingResult)
|
|
}
|
|
}
|
|
} catch {
|
|
// Cleanup the temp file in the event that the multipart form data encoding failed
|
|
if let tempFileURL = tempFileURL {
|
|
do {
|
|
try FileManager.default.removeItem(at: tempFileURL)
|
|
} catch {
|
|
// No-op
|
|
}
|
|
}
|
|
|
|
DispatchQueue.main.async { encodingCompletion?(.failure(error)) }
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: Private - Upload Implementation
|
|
|
|
private func upload(_ uploadable: UploadRequest.Uploadable) -> UploadRequest {
|
|
do {
|
|
let task = try uploadable.task(session: session, adapter: adapter, queue: queue)
|
|
let upload = UploadRequest(session: session, requestTask: .upload(uploadable, task))
|
|
|
|
if case let .stream(inputStream, _) = uploadable {
|
|
upload.delegate.taskNeedNewBodyStream = { _, _ in inputStream }
|
|
}
|
|
|
|
delegate[task] = upload
|
|
|
|
if startRequestsImmediately { upload.resume() }
|
|
|
|
return upload
|
|
} catch {
|
|
return upload(uploadable, failedWith: error)
|
|
}
|
|
}
|
|
|
|
private func upload(_ uploadable: UploadRequest.Uploadable?, failedWith error: Error) -> UploadRequest {
|
|
var uploadTask: Request.RequestTask = .upload(nil, nil)
|
|
|
|
if let uploadable = uploadable {
|
|
uploadTask = .upload(uploadable, nil)
|
|
}
|
|
|
|
let underlyingError = error.underlyingAdaptError ?? error
|
|
let upload = UploadRequest(session: session, requestTask: uploadTask, error: underlyingError)
|
|
|
|
if let retrier = retrier, error is AdaptError {
|
|
allowRetrier(retrier, toRetry: upload, with: underlyingError)
|
|
} else {
|
|
if startRequestsImmediately { upload.resume() }
|
|
}
|
|
|
|
return upload
|
|
}
|
|
|
|
#if !os(watchOS)
|
|
|
|
// MARK: - Stream Request
|
|
|
|
// MARK: Hostname and Port
|
|
|
|
/// Creates a `StreamRequest` for bidirectional streaming using the `hostname` and `port`.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// - parameter hostName: The hostname of the server to connect to.
|
|
/// - parameter port: The port of the server to connect to.
|
|
///
|
|
/// - returns: The created `StreamRequest`.
|
|
@discardableResult
|
|
@available(iOS 9.0, macOS 10.11, tvOS 9.0, *)
|
|
open func stream(withHostName hostName: String, port: Int) -> StreamRequest {
|
|
return stream(.stream(hostName: hostName, port: port))
|
|
}
|
|
|
|
// MARK: NetService
|
|
|
|
/// Creates a `StreamRequest` for bidirectional streaming using the `netService`.
|
|
///
|
|
/// If `startRequestsImmediately` is `true`, the request will have `resume()` called before being returned.
|
|
///
|
|
/// - parameter netService: The net service used to identify the endpoint.
|
|
///
|
|
/// - returns: The created `StreamRequest`.
|
|
@discardableResult
|
|
@available(iOS 9.0, macOS 10.11, tvOS 9.0, *)
|
|
open func stream(with netService: NetService) -> StreamRequest {
|
|
return stream(.netService(netService))
|
|
}
|
|
|
|
// MARK: Private - Stream Implementation
|
|
|
|
@available(iOS 9.0, macOS 10.11, tvOS 9.0, *)
|
|
private func stream(_ streamable: StreamRequest.Streamable) -> StreamRequest {
|
|
do {
|
|
let task = try streamable.task(session: session, adapter: adapter, queue: queue)
|
|
let request = StreamRequest(session: session, requestTask: .stream(streamable, task))
|
|
|
|
delegate[task] = request
|
|
|
|
if startRequestsImmediately { request.resume() }
|
|
|
|
return request
|
|
} catch {
|
|
return stream(failedWith: error)
|
|
}
|
|
}
|
|
|
|
@available(iOS 9.0, macOS 10.11, tvOS 9.0, *)
|
|
private func stream(failedWith error: Error) -> StreamRequest {
|
|
let stream = StreamRequest(session: session, requestTask: .stream(nil, nil), error: error)
|
|
if startRequestsImmediately { stream.resume() }
|
|
return stream
|
|
}
|
|
|
|
#endif
|
|
|
|
// MARK: - Internal - Retry Request
|
|
|
|
func retry(_ request: Request) -> Bool {
|
|
guard let originalTask = request.originalTask else { return false }
|
|
|
|
do {
|
|
let task = try originalTask.task(session: session, adapter: adapter, queue: queue)
|
|
|
|
request.delegate.task = task // resets all task delegate data
|
|
|
|
request.retryCount += 1
|
|
request.startTime = CFAbsoluteTimeGetCurrent()
|
|
request.endTime = nil
|
|
|
|
task.resume()
|
|
|
|
return true
|
|
} catch {
|
|
request.delegate.error = error.underlyingAdaptError ?? error
|
|
return false
|
|
}
|
|
}
|
|
|
|
private func allowRetrier(_ retrier: RequestRetrier, toRetry request: Request, with error: Error) {
|
|
DispatchQueue.utility.async { [weak self] in
|
|
guard let strongSelf = self else { return }
|
|
|
|
retrier.should(strongSelf, retry: request, with: error) { shouldRetry, timeDelay in
|
|
guard let strongSelf = self else { return }
|
|
|
|
guard shouldRetry else {
|
|
if strongSelf.startRequestsImmediately { request.resume() }
|
|
return
|
|
}
|
|
|
|
DispatchQueue.utility.after(timeDelay) {
|
|
guard let strongSelf = self else { return }
|
|
|
|
let retrySucceeded = strongSelf.retry(request)
|
|
|
|
if retrySucceeded, let task = request.task {
|
|
strongSelf.delegate[task] = request
|
|
} else {
|
|
if strongSelf.startRequestsImmediately { request.resume() }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|