To upload in a background session, the data must first saved to a file.
- Save the data to file using writeToFile:options:.
- Call NSURLSession uploadTaskWithRequest:fromFile: to create the task. Note that the request must not contain the data in the
HTTPBody
otherwise the upload will fail.
- Handle completion in the URLSession:didCompleteWithError: delegate method.
You may also want to handle uploads which complete while the app is in the background.
- Implement application:handleEventsForBackgroundURLSession:completionHandler in the AppDelegate.
- Create an NSURLSession with the provided identifier.
- Respond to the delegate methods as per a usual upload (e.g. handle the response in URLSession:didCompleteWithError:)
- Call URLSessionDidFinishEventsForBackgroundURLSession when you have completed processing the event.
To make this easier to manage, create one NSURLSession
per upload task, each with a unique identifier.
Refer to the URL Session Programming Guide for implementation details.
Example AppDelegate:
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate, NSURLSessionDelegate, NSURLSessionTaskDelegate {
var window: UIWindow?
typealias CompletionHandler = () -> Void
var completionHandlers = [String: CompletionHandler]()
var sessions = [String: NSURLSession]()
func upload(request: NSURLRequest, data: NSData)
{
// Create a unique identifier for the session.
let sessionIdentifier = NSUUID().UUIDString
let directoryURL = NSFileManager.defaultManager().URLsForDirectory(.CachesDirectory, inDomains: .UserDomainMask).first!
let fileURL = directoryURL.URLByAppendingPathComponent(sessionIdentifier)
// Write data to cache file.
data.writeToURL(fileURL, atomically: true);
let configuration = NSURLSessionConfiguration.backgroundSessionConfigurationWithIdentifier(sessionIdentifier)
let session: NSURLSession = NSURLSession(
configuration:configuration,
delegate: self,
delegateQueue: NSOperationQueue.mainQueue()
)
// Store the session, so that we don't recreate it if app resumes from suspend.
sessions[sessionIdentifier] = session
let task = session.uploadTaskWithRequest(request, fromFile: fileURL)
task.resume()
}
// Called when the app becomes active, if an upload completed while the app was in the background.
func application(application: UIApplication, handleEventsForBackgroundURLSession identifier: String, completionHandler: CompletionHandler) {
let configuration = NSURLSessionConfiguration.backgroundSessionConfigurationWithIdentifier(identifier)
if sessions[identifier] == nil {
let session = NSURLSession(
configuration: configuration,
delegate: self,
delegateQueue: NSOperationQueue.mainQueue()
)
sessions[identifier] = session
}
completionHandlers[identifier] = completionHandler
}
func URLSession(session: NSURLSession, task: NSURLSessionTask, didCompleteWithError error: NSError?) {
// Handle background session completion handlers.
if let identifier = session.configuration.identifier {
if let completionHandler = completionHandlers[identifier] {
completionHandler()
completionHandlers.removeValueForKey(identifier)
}
// Remove session
sessions.removeValueForKey(identifier)
}
// Upload completed.
}
}
To upload multiple images in a single request, the images must first be encoded into the multipart/formdata MIME type, as you have done. The difference being that this entire MIME message must be saved to a single file, which is the file that is uploaded to the server.
Here is an example which shows how to do this. It works by serialising the MIME parts directly to a file. You could also build up the message in an NSData, although you risk running into memory limitations when handling large files.
func uploadImages(request: NSURLRequest, images: [UIImage]) {
let uuid = NSUUID().UUIDString
let boundary = String(count: 24, repeatedValue: "-" as Character) + uuid
// Open the file
let directoryURL = NSFileManager.defaultManager().URLsForDirectory(.CachesDirectory, inDomains: .UserDomainMask).first!
let fileURL = directoryURL.URLByAppendingPathComponent(uuid)
let filePath = fileURL.path!
NSFileManager.defaultManager().createFileAtPath(filePath, contents: nil, attributes: nil)
let file = NSFileHandle(forWritingAtPath: filePath)!
// Write each image to a MIME part.
let newline = "\r\n"
for (i, image) in images.enumerate() {
let partName = "image-\(i)"
let partFilename = "\(partName).png"
let partMimeType = "image/png"
let partData = UIImagePNGRepresentation(image)
// Write boundary header
var header = ""
header += "--\(boundary)" + newline
header += "Content-Disposition: form-data; name=\"\(partName)\"; filename=\"\(partFilename)\"" + newline
header += "Content-Type: \(partMimeType)" + newline
header += newline
let headerData = header.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)
print("")
print("Writing header #\(i)")
print(header)
print("Writing data")
print("\(partData!.length) Bytes")
// Write data
file.writeData(headerData!)
file.writeData(partData!)
}
// Write boundary footer
var footer = ""
footer += newline
footer += "--\(boundary)--" + newline
footer += newline
print("")
print("Writing footer")
print(footer)
let footerData = footer.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)
file.writeData(footerData!)
file.closeFile()
// Add the content type for the request to multipart.
let outputRequest = request.copy() as! NSMutableURLRequest
let contentType = "multipart/form-data; boundary=\(boundary)"
outputRequest.setValue(contentType, forHTTPHeaderField: "Content-Type")
// Start uploading files.
upload(outputRequest, fileURL: fileURL)
}