Swift (iOS), waiting for all images to finish downloading before returning

Question

I am writing a Swift iOS app (my first, so please bear with me) where I use Swifter HTTP server to process various requests. One such request is an HTTP POST with a JSON array specifying images to download from the web (and do some other stuff, not pertinent to the issue at hand).

I use Alamofire to download the images (this works fine), but I am looking for good (preferably simple) way to wait for all the images to finish downloading before returning a response to the POST request above (since the response has to contain JSON indicating the result, including any failed downloads).

What is a good way to accomplish this (preferably w/o blocking the main thread)?

Here are some snippets to illustrate:

public func webServer(publicDir: String?) -> HttpServer {
  let server = HttpServer()

  server.POST["/images/update"] = { r in
        let images = ...(from JSON array in body)
        let updateResult = ImageUtil.updateImages(images)
        let resultJson: String = Mapper().toJSONString(updateResult, prettyPrint: true)!

        if updateResult.success {
            return .OK(.Text(resultJson))
        }
        return HttpResponse.RAW(500, "Error", nil, { $0.write([UInt8](updateResult.errorMessage.utf8)) })
    }
}

static func updateImages(images: [ImageInfo]) -> UpdateResult {
  let updateResult = UpdateResult()
  for image in images {
    Alamofire.download(.GET, serverFile.imageUrl) { temporaryURL, response in return destinationPath }
        .validate()
        .response{_, _, _, error in
            if let error = error {
                Log.error?.message("Error downloading file \(image.imageUrl) to \(image.fileName): \(error)")
            } else {
                updateResult.filesDownloaded++
                Log.info?.message("Downloaded file \(image.imageUrl) to \(image.fileName)")
            }}
    }

    return updateResult // It obviously returns before any images finish downloading.  I need to wait until all images have downloaded before I can return an accurate result.
}

Update 1/23/2016, using dispatcher per bbum

This is an attempt to use the dispatcher mechanism, but the call to updateImages still return right away (even when using dispatch_sync).

How can I await the completion of all downloads before returning my HTTP response to the caller?

public func webServer(publicDir: String?) -> HttpServer {
    let server = HttpServer()

    server.POST["/images/update"] = { r in
        let imageDownloader = ImageDownloader()
        imageDownloader.updateimageFiles(adFilesOnServer)
        let resultJson: String = Mapper().toJSONString(imageDownloader.updateResult, prettyPrint: true)!

        if imageDownloader.updateResult.success {
            return .OK(.Text(resultJson))
        }
        return HttpResponse.RAW(500, "Error", nil, { $0.write([UInt8](imageDownloader.updateResult.errorMessage.utf8)) })
    }
}

class ImageDownloader {

    var updateResult = AdUpdateResult()
    private var imageFilesOnServer = [ImageFile]()

    private let fileManager = NSFileManager.defaultManager()
    private let imageDirectoryURL = NSURL(fileURLWithPath: Settings.imageDirectory, isDirectory: true)

    private let semaphore = dispatch_semaphore_create(4)
    private let downloadQueue = dispatch_queue_create("com.acme.downloader", DISPATCH_QUEUE_SERIAL)

    func updateimageFiles(imageFilesOnServer: [ImageFile]) {
        self.imageFilesOnServer = imageFilesOnServer

        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER)

        for serverFile in imageFilesOnServer {
            downloadImageFileFromServer(serverFile)
        }

        dispatch_sync(downloadQueue) {
            dispatch_sync(dispatch_get_main_queue()) {
                print("done") // It gets here before images have downloaded.
            }
        }
    }

    private func downloadImageFileFromServer(serverFile: ImageFile) {

        let destinationPath = imageDirectoryURL.URLByAppendingPathComponent(serverFile.fileName)

        Alamofire.download(.GET, serverFile.imageUrl) { temporaryURL, response in return destinationPath }
        .validate()
        .response { _, _, _, error in
            if let error = error {
                Log.error?.message("Error downloading file \(serverFile.imageUrl) to \(serverFile.fileName): \(error)")
            } else {
                self.updateResult.filesDownloaded++
                Log.info?.message("Downloaded file \(serverFile.imageUrl) to \(serverFile.fileName)")
            }
            dispatch_semaphore_signal(self.semaphore)
        }
    }
}

Answer 1

First, you really don't want to be firing off a request-per-image without some kind of a throttle. Semaphores work well for that sort of thing.

Secondly, you need to basically count the number of operations outstanding and then fire a completion handler when they are all done. Or, if new operations can be started at any time, you'll probably want to group operations.

So, pseudo code:

sema = dispatch_semaphore_create(4) // 4 being # of concurrent operations allowed
serialQ = dispatch_queue_create(.., SERIAL)

dispatch_async(serialQ) {
    dispatch_semaphore_wait(sema, FOREVER) // will block if there are 4 in flight already
    for image in images {
        downloader.downloadAsync(image, ...) { // completion
              dispatch_semaphore_signal(sema) // signal that we are done with one
              ... handle downloaded image or error ...
              ... add downloaded images to downloadedImages ...
        }
    }
}

dispatch_async(serialQ) {
     // since serialQ is serial, this will be executed after the downloads are done
    dispatch_async(main_queue()) {
         yo_main_queue_here_be_yer_images(... downloadedImages ...)
    }
}