Téléchargez des images multiples dans swift à l'aide de Alamofire

J'utilise le code suivant pour télécharger une image unique pour un serveur:

private static func urlRequestWithComponents(urlString:String, parameters:Dictionary<String, String>, imageData:NSData?, imageName: String) -> (URLRequestConvertible , NSData) {

    //create url request to send
    let mutableURLRequest = NSMutableURLRequest(URL: NSURL(string: urlString)!)
    mutableURLRequest.HTTPMethod = Alamofire.Method.POST.rawValue
    let boundaryConstant = "myRandomBoundary12345";
    let contentType = "multipart/form-data;boundary="+boundaryConstant
    mutableURLRequest.setValue(contentType, forHTTPHeaderField: "Content-Type")


    //create upload data to send
    let uploadData = NSMutableData()
    if(imageData != nil && imageData?.length != 0) {
        //add image
        uploadData.appendData("\r\n--\(boundaryConstant)\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
        uploadData.appendData("Content-Disposition: form-data; name=\"\(imageName)\"; filename=\"\(StringHelper.sharedInstance.randomString(5)).png\"\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
        uploadData.appendData("Content-Type: image/png\r\n\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
        uploadData.appendData(imageData!)
    }
    //add parameters
    for (key, value) in parameters {
        uploadData.appendData("\r\n--\(boundaryConstant)\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
        uploadData.appendData("Content-Disposition: form-data; name=\"\(key)\"\r\n\r\n\(value)".dataUsingEncoding(NSUTF8StringEncoding)!)
    }
    uploadData.appendData("\r\n--\(boundaryConstant)--\r\n".dataUsingEncoding(NSUTF8StringEncoding)!)
    print("upload",parameters)
    //return URLRequestConvertible and NSData
    return (Alamofire.ParameterEncoding.URL.encode(mutableURLRequest, parameters: nil).0, uploadData)
}

Comment puis-je télécharger plusieurs images dans un seul paramètre en modifiant ce code?

comment pouvez télécharger des images multiples de tableau dans un seul pararmeter
Vous pouvez faire une structure qui prend tous vos func params, puis de créer une fonction qui prend un tableau de ces structures, puis dans la fonction, vous pouvez parcourir le tableau et retourne un tableau de demandes. Si vous voulez tout faire à la fois parce que vous avez besoin de faire quelque chose lorsque tous les téléchargements sont terminés, d'examiner le Fonctionnement de la file d'attente ou de l'Envoi Groupe
Veuillez consulter le lien stackoverflow.com/questions/28448837/..., stackoverflow.com/questions/40527140/...

InformationsquelleAutor Arun sharma | 2017-01-06

34

Swift 3
Suffit d'utiliser "[]" avec l'upload d'images param pour faire tableau d'images.
```
Alamofire.upload(multipartFormData: { multipartFormData in
            //import image to request
            for imageData in imagesData {
                multipartFormData.append(imageData, withName: "\(imageParamName)[]", fileName: "\(Date().timeIntervalSince1970).jpeg", mimeType: "image/jpeg")
            }
            for (key, value) in parameters {
                multipartFormData.append(value.data(using: String.Encoding.utf8)!, withName: key)
            }
        }, to: urlString,

            encodingCompletion: { encodingResult in
                switch encodingResult {
                case .success(let upload, _, _):
                    upload.responseJSON { response in

                    }
                case .failure(let error):
                    print(error)
                }

        })
```
- À court et moyen simple de télécharger plusieurs images , Merci
- Pouvez-vous nous expliquer l'extrait de code ci-dessus?
- Le code ci-dessus est de télécharger plusieurs images de la collection, selon le code de Données d'images (Fondation.De données) dans imagesData tableau. le problème est qu'il est primordial de l'image précédente valeur de données lors de la création de mutipartFormData à l'aide de l'itération. Mais en ajoutant [ ] entre crochets à la fin de l'param name il est capable de charger les données dans le tableau. C'est tout. Même chose que vous pouvez voir dans le postier application à télécharger tableau d'images. Merci. Veuillez upvote si c'est ok.
- Pouvez-vous nous dire ce que avec name: "(imageParamName)[]" dans le code ci-dessus??
- avec name est le param accepter le nom de la clé de données de médias, comme la valeur envoyée dans ‘imageParamName variable, l'utilisation de crochets ‘[ ]’ est d'identifier ce qu'ils param contenir des valeurs de tableau.
- ok..devons-nous déclarer imageParamName avant de l'utiliser car il me donne l'erreur sur ce nom?
- oui vous avez besoin de ce type de chaîne variable/constante, qui contiennent la valeur de la clé de vos images param.
InformationsquelleAutor Gurjit Singh

Ce un m'aide:

private func urlRequestWithComponentsForUploadMultipleImages(urlString:String, parameters:Dictionary<String, String>, imagesData:[Data], imageName: String) -> (URLRequestConvertible , Data) {

    //create url request to send
    var mutableURLRequest = URLRequest(url: NSURL(string: urlString)! as URL)

    mutableURLRequest.httpMethod = Alamofire.HTTPMethod.post.rawValue
    let boundaryConstant = "myRandomBoundary12345";
    let contentType = "multipart/form-data;boundary="+boundaryConstant
    mutableURLRequest.setValue(contentType, forHTTPHeaderField: "Content-Type")


    //create upload data to send
    var uploadData = Data()
    //add image
    for data in imagesData {
        uploadData.append("\r\n--\(boundaryConstant)\r\n".data(using: String.Encoding.utf8)!)
        uploadData.append("Content-Disposition: form-data; name=\"\(imageName)\"; filename=\"\(Date().timeIntervalSince1970).jpeg\"\r\n".data(using: String.Encoding.utf8)!)
        uploadData.append("Content-Type: image/jpeg\r\n\r\n".data(using: String.Encoding.utf8)!)
        uploadData.append(data)
    }
    //add parameters
    for (key, value) in parameters {
        uploadData.append("\r\n--\(boundaryConstant)\r\n".data(using: String.Encoding.utf8)!)
        uploadData.append("Content-Disposition: form-data; name=\"\(key)\"\r\n\r\n\(value)".data(using: String.Encoding.utf8)!)
    }
    uploadData.append("\r\n--\(boundaryConstant)--\r\n".data(using: String.Encoding.utf8)!)
    print("upload",parameters)
    return (mutableURLRequest , uploadData)
}

InformationsquelleAutor Arun sharma

Il ressemble à cette question a déjà été répondu, et probablement dans plusieurs endroits. Voici un lien que j'ai trouvé:

Comment télécharger plusieurs images en plusieurs parties à l'aide de Alamofire?

Je vais coller leur solution pour des raisons de commodité, mais ils ont dit qu'il travaille pour Swift 3.x:

//MARK: - upload multiple photos

func uploadImagesAndData(params:[String : AnyObject]?,image1: UIImage,image2: UIImage,image3: UIImage,image4: UIImage,headers : [String : String]?, completionHandler:@escaping CompletionHandler) -> Void {
let imageData1 = UIImageJPEGRepresentation(image1, 0.5)!
let imageData2 = UIImageJPEGRepresentation(image2, 0.5)!
let imageData3 = UIImageJPEGRepresentation(image3, 0.5)!
let imageData4 = UIImageJPEGRepresentation(image4, 0.5)!
Alamofire.upload(multipartFormData: { multipartFormData in
for (key, value) in params! {
if let data = value.data(using: String.Encoding.utf8.rawValue) {
multipartFormData.append(data, withName: key)
}
}
multipartFormData.append(imageData1, withName: "file", fileName: "image.jpg", mimeType: "image/jpeg")
multipartFormData.append(imageData2, withName: "file", fileName: "image.jpg", mimeType: "image/jpeg")
multipartFormData.append(imageData3, withName: "file", fileName: "image.jpg", mimeType: "image/jpeg")
multipartFormData.append(imageData4, withName: "file", fileName: "image.jpg", mimeType: "image/jpeg")
},
to: K_BASEURL + K_API_LOGINDATA, encodingCompletion: { encodingResult in
switch encodingResult {
case .success(let upload, _, _):
upload
.validate()
.responseJSON { response in
switch response.result {
case .success(let value):
print("responseObject: \(value)")
case .failure(let responseError):
print("responseError: \(responseError)")
}
}
case .failure(let encodingError):
print("encodingError: \(encodingError)")
}
})

La solution semble être basé sur l'approche recommandée détaillée dans le Alamofire documentation ici: https://github.com/Alamofire/Alamofire#uploading-multipartformdata

Alamofire.upload(
multipartFormData: { multipartFormData in
multipartFormData.append(unicornImageURL, withName: "unicorn")
multipartFormData.append(rainbowImageURL, withName: "rainbow")
},
to: "https://httpbin.org/post",
encodingCompletion: { encodingResult in
switch encodingResult {
case .success(let upload, _, _):
upload.responseJSON { response in
debugPrint(response)
}
case .failure(let encodingError):
print(encodingError)
}
})

InformationsquelleAutor Lobsterman

voici ma solution et il sera à 100% pas de bugs..

        Alamofire.upload(multipartFormData: { (multipartFormData : MultipartFormData) in
let count = imageToUpload.count
for i in 0..<count{
multipartFormData.append(imageToUpload[i], withName: "morephoto[\(i)]", fileName: "photo\(i).jpeg" , mimeType: "image/jpeg")
}
for (key, value) in parameterrs {
multipartFormData.append((value as AnyObject).data(using: String.Encoding.utf8.rawValue)!, withName: key)
}
print(multipartFormData)
}, to: url!) { (result) in
switch result {
case .success(let upload, _ , _):
upload.uploadProgress(closure: { (progress) in
print("uploding: \(progress.fractionCompleted)")
})
upload.responseJSON { response in
print(response.result.value!)
let resp = response.result.value! as! NSDictionary
if resp["status"] as! String == "success"{
print(response.result.value!)
let alert = UIAlertController(title: "Alert", message: "Image Upload Successful", preferredStyle: UIAlertControllerStyle.alert)
alert.addAction(UIAlertAction(title: "Okay", style: UIAlertActionStyle.default, handler: nil))
self.present(alert, animated: true, completion: nil)
}
else{
}
}
case .failure(let encodingError):
print("failed")
print(encodingError)
}
}

dans ce imagetoupload tableau est le tableau des données de l'image que j'ai faite avant.

InformationsquelleAutor ap00724

Vous devez vous connecter pour publier un commentaire.