siva ganesh siva ganesh - 9 months ago 370
Swift Question

Background upload multiple images using single NSURLSession uploadTaskWithRequest

I want to upload multiple images in background using a single

method. While trying the following code returns Upload tasks from NSData are not supported in background sessions...please how to achieve this

func createRequest (param : NSDictionary ,imagearray :NSMutableArray, strURL : String) -> NSURLRequest {

let boundary = generateBoundaryString()

let url = NSURL(string: strURL)
let request = NSMutableURLRequest(URL: url!)

request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
request.HTTPMethod = "POST"
request.HTTPBody = createBodyWithParameters(param, image_array:imagearray,boundary: boundary);

return request

func createBodyWithParameters(parameters: NSDictionary,image_array:NSMutableArray,boundary: String) -> NSData {
let body = NSMutableData()
for (key, value) in parameters {
if(value is String || value is NSString){
body.appendString("Content-Disposition: form-data; name=\"\(key)\"\r\n\r\n")
var i = 0;
for image in image_array {
let filename = "image\(i).jpg"
let data = UIImagePNGRepresentation(image as! UIImage);
let mimetype = "image/png"
body.appendString("Content-Disposition: form-data; name=\"\(self.filePathKey)\"; filename=\"\(filename)\"\r\n")
body.appendString("Content-Type: \(mimetype)\r\n\r\n")
i += 1;

// NSLog("data %@",NSString(data: body, encoding: NSUTF8StringEncoding)!);
return body

func postrequestwithformdata(requesturl:String,postparams:NSDictionary,postformadata:NSMutableArray,requestId:Int)

self.requestid = requestId;
let requestformdata = self.createRequest(postparams, imagearray: postformadata, strURL: requesturl);
let configuration = NSURLSessionConfiguration.backgroundSessionConfigurationWithIdentifier(Contants.identifier)
let session: NSURLSession = NSURLSession(configuration:configuration, delegate: self, delegateQueue: NSOperationQueue.mainQueue());
let task: NSURLSessionUploadTask = session.uploadTaskWithRequest(requestformdata, fromData: requestformdata.HTTPBody!);



To upload in a background session, the data must first saved to a file.

  1. Save the data to file using writeToFile:options:.
  2. 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.
  3. Handle completion in the URLSession:didCompleteWithError: delegate method.

You may also want to handle uploads which complete while the app is in the background.

  1. Implement application:handleEventsForBackgroundURLSession:completionHandler in the AppDelegate.
  2. Create an NSURLSession with the provided identifier.
  3. Respond to the delegate methods as per a usual upload (e.g. handle the response in URLSession:didCompleteWithError:)
  4. 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:

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(
            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)


    // 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] {

            // Remove session

        // 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("Writing header #\(i)")

        print("Writing data")
        print("\(partData!.length) Bytes")

        // Write data

    // Write boundary footer
    var footer = ""
    footer += newline
    footer += "--\(boundary)--" + newline
    footer += newline

    print("Writing footer")

    let footerData = footer.dataUsingEncoding(NSUTF8StringEncoding, allowLossyConversion: false)


    // 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)