从iOS设备高效上传多张图片到S3的方法

Question

我在我的应用程序中使用Amazon S3作为文件存储系统。 我所有的项目对象都有几个与它们相关联的图像，并且每个对象只存储图像URL以使我的数据库轻巧。 因此，我需要一种有效的方法来直接从iOS上传多个图像到S3，并在成功完成后将它们的URL存储在发送到服务器的对象中。 我已经查阅了Amazon提供的SDK和示例应用程序，但我找到的唯一示例是单个图像上传，并且如下：

 func uploadData(data: NSData) {
    let expression = AWSS3TransferUtilityUploadExpression()
    expression.progressBlock = progressBlock

    let transferUtility = AWSS3TransferUtility.defaultS3TransferUtility()

    transferUtility.uploadData(
        data,
        bucket: S3BucketName,
        key: S3UploadKeyName,
        contentType: "text/plain",
        expression: expression,
        completionHander: completionHandler).continueWithBlock { (task) -> AnyObject! in
            if let error = task.error {
                NSLog("Error: %@",error.localizedDescription);
                self.statusLabel.text = "Failed"
            }
            if let exception = task.exception {
                NSLog("Exception: %@",exception.description);
                self.statusLabel.text = "Failed"
            }
            if let _ = task.result {
                self.statusLabel.text = "Generating Upload File"
                NSLog("Upload Starting!")
                // Do something with uploadTask.
            }

            return nil;
    }
}

对于超过5个图片，我需要等待每个上传成功后才能启动下一个上传，最后将对象发送到我的数据库中，这将导致嵌套混乱。有没有一种高效、代码清晰的方法来实现我的目标呢？

亚马逊示例应用程序github的URL：https://github.com/awslabs/aws-sdk-ios-samples/tree/master/S3TransferUtility-Sample/Swift

- David Tamrazov

---

你解决了吗？我也在寻找同样的东西。 - user2722667

@user2722667，请查看我的回复。可能有点晚了，但肯定会有所帮助。 - Bonnke

Answer 1

这是我用来将多个图片同时上传到S3的代码，使用了DispatchGroup()。

func uploadOfferImagesToS3() {
    let group = DispatchGroup()

    for (index, image) in arrOfImages.enumerated() {
        group.enter()

        Utils.saveImageToTemporaryDirectory(image: image, completionHandler: { (url, imgScalled) in
            if let urlImagePath = url,
                let uploadRequest = AWSS3TransferManagerUploadRequest() {
                uploadRequest.body          = urlImagePath
                uploadRequest.key           = ProcessInfo.processInfo.globallyUniqueString + "." + "png"
                uploadRequest.bucket        = Constants.AWS_S3.Image
                uploadRequest.contentType   = "image/" + "png"
                uploadRequest.uploadProgress = {(bytesSent:Int64, totalBytesSent:Int64, totalBytesExpectedToSend:Int64) in
                    let uploadProgress = Float(Double(totalBytesSent)/Double(totalBytesExpectedToSend))

                    print("uploading image \(index) of \(arrOfImages.count) = \(uploadProgress)")

                    //self.delegate?.amazonManager_uploadWithProgress(fProgress: uploadProgress)
                }

                self.uploadImageStatus      = .inProgress

                AWSS3TransferManager.default()
                    .upload(uploadRequest)
                    .continueWith(executor: AWSExecutor.immediate(), block: { (task) -> Any? in

                        group.leave()

                        if let error = task.error {
                            print("\n\n=======================================")
                            print("❌ Upload image failed with error: (\(error.localizedDescription))")
                            print("=======================================\n\n")

                            self.uploadImageStatus = .failed
                            self.delegate?.amazonManager_uploadWithFail()

                            return nil
                        }

                        //=>    Task completed successfully
                        let imgS3URL = Constants.AWS_S3.BucketPath + Constants.AWS_S3.Image + "/" + uploadRequest.key!
                        print("imgS3url = \(imgS3URL)")
                        NewOfferManager.shared.arrUrlsImagesNewOffer.append(imgS3URL)

                        self.uploadImageStatus = .completed
                        self.delegate?.amazonManager_uploadWithSuccess(strS3ObjUrl: imgS3URL, imgSelected: imgScalled)

                        return nil
                    })
            }
            else {
                print(" Unable to save image to NSTemporaryDirectory")
            }
        })
    }

    group.notify(queue: DispatchQueue.global(qos: .background)) {
        print("All \(arrOfImages.count) network reqeusts completed")
    }
}

这是关键的部分，我在这里浪费了至少5个小时。 NSTemporaryDirectory中的URL必须对于每个图像都不同!!!

class func saveImageToTemporaryDirectory(image: UIImage, completionHandler: @escaping (_ url: URL?, _ imgScalled: UIImage) -> Void) {
    let imgScalled              = ClaimitUtils.scaleImageDown(image)
    let data                    = UIImagePNGRepresentation(imgScalled)

    let randomPath = "offerImage" + String.random(ofLength: 5)

    let urlImgOfferDir = URL(fileURLWithPath: NSTemporaryDirectory().appending(randomPath))
    do {
        try data?.write(to: urlImgOfferDir)
        completionHandler(urlImgOfferDir, imgScalled)
    }
    catch (let error) {
        print(error)
        completionHandler(nil, imgScalled)
    }
}

希望这能帮到你！

- Bonnke

---

我正在使用你分享的相同代码，但出现了问题，请问你能帮我看看我做错了什么吗？上传图片失败，错误信息为：（操作无法完成。（com.amazonaws.AWSCognitoIdentityErrorDomain 错误 10.）） - Dilip Mishra

@Bonnke 你能否像这样显示一些进度：上传图像1/5，然后如果第一张图像上传成功，则更新计数器为2/5。类似这样的东西？另外，你的代码是按顺序上传还是并行上传？ - Rahul Vyas

Answer 2

如我在H. Al-Amri的回答中所说，如果您需要知道最后一次上传完成的时间，您不能简单地遍历数据数组并一次性上传它们。

在Javascript中有一个库（我认为是Async.js）可以轻松地对数组中的单个元素执行后台操作，并在每个元素完成和整个数组完成时得到回调。由于我不知道是否有与Swift类似的东西，您正确地想到了必须链式上传。

正如@DavidTamrazov在评论中解释的那样，您可以使用递归将调用链接在一起。我解决这个问题的方法有点复杂，因为我的网络操作是使用NSOperationQueue链接NSOperations完成的。我向一个自定义NSOperation传递图像数组，该NSOperation会上传数组中的第一个图像。当它完成时，它会向我的NSOperationsQueue添加另一个NSOperation，其中包含剩余图像的数组。当数组用完时，我就知道完成了。

以下是我从我使用的更大的代码块中切出来的示例。将其视为伪代码，因为我进行了大量编辑，甚至没有时间编译它。但是希望它清楚地说明如何使用NSOperations进行此操作的框架。

class NetworkOp : Operation {
    var isRunning = false

    override var isAsynchronous: Bool {
        get {
            return true
        }
    }

    override var isConcurrent: Bool {
        get {
            return true
        }
    }

    override var isExecuting: Bool {
        get {
            return isRunning
        }
    }

    override var isFinished: Bool {
        get {
            return !isRunning
        }
    }

    override func start() {
        if self.checkCancel() {
            return
        }
        self.willChangeValue(forKey: "isExecuting")
        self.isRunning = true
        self.didChangeValue(forKey: "isExecuting")
        main()
    }

    func complete() {
        self.willChangeValue(forKey: "isFinished")
        self.willChangeValue(forKey: "isExecuting")
        self.isRunning = false
        self.didChangeValue(forKey: "isFinished")
        self.didChangeValue(forKey: "isExecuting")
        print( "Completed net op: \(self.className)")
    }

    // Always resubmit if we get canceled before completion
    func checkCancel() -> Bool {
        if self.isCancelled {
            self.retry()
            self.complete()
        }
        return self.isCancelled
    }

    func retry() {
        // Create a new NetworkOp to match and resubmit since we can't reuse existing.
    }

    func success() {
        // Success means reset delay
        NetOpsQueueMgr.shared.resetRetryIncrement()
    }
}

class ImagesUploadOp : NetworkOp {
    var imageList : [PhotoFileListMap]

    init(imageList : [UIImage]) {
        self.imageList = imageList
    }

    override func main() {
        print( "Photos upload starting")
        if self.checkCancel() {
            return
        }

        // Pop image off front of array
        let image = imageList.remove(at: 0)

        // Now call function that uses AWS to upload image, mine does save to file first, then passes
        // an error message on completion if it failed, nil if it succceeded
        ServerMgr.shared.uploadImage(image: image, completion: {  errorMessage ) in
            if let error = errorMessage {
                print("Failed to upload file - " + error)
                self.retry()
            } else {
                print("Uploaded file")
                if !self.isCancelled {
                    if self.imageList.count == 0 {
                        // All images done, here you could call a final completion handler or somthing.
                    } else {
                        // More images left to do, let's put another Operation on the barbie:)
                        NetOpsQueueMgr.shared.submitOp(netOp: ImagesUploadOp(imageList: self.imageList))
                    }
                }
            }
            self.complete()
         })
    }

    override func retry() {
        NetOpsQueueMgr.shared.retryOpWithDelay(op: ImagesUploadOp(form: self.form, imageList: self.imageList))
    }
}


// MARK: NetOpsQueueMgr  -------------------------------------------------------------------------------

class NetOpsQueueMgr {
    static let shared = NetOpsQueueMgr()

    lazy var opsQueue :OperationQueue = {
        var queue = OperationQueue()
        queue.name = "myQueName"
        queue.maxConcurrentOperationCount = 1
        return queue
    }()

    func submitOp(netOp : NetworkOp) {
         opsQueue.addOperation(netOp)
    }

   func uploadImages(imageList : [UIImage]) {
        let imagesOp = ImagesUploadOp(form: form, imageList: imageList)
        self.submitOp(netOp: imagesOp)
    }
}

- SafeFastExpressive

---

这是一个很好的选择，充分利用了现有的Swift类，谢谢！我最终使用了一个递归函数，它以图像数组作为参数，并且与您的逻辑类似，一旦传递给它的数组为空，它就会终止。我只在成功上传图像后进行递归，以确保一致性。 - David Tamrazov

谢谢@DavidTamrazov，你是正确的，这不是唯一的方法，事实上你的方法更直接，也是SO更好的例子。我会更新我的答案来提到这点。 - SafeFastExpressive