Valore non valido di Alamofire intorno al carattere 0

Alamofire.request(.GET, "url").authenticate(user: "", password: "").responseJSON() {
    (request, response, json, error) in
    println(error)
    println(json)

}

Questa è la mia richiesta con Alamofire, per una certa richiesta a volte funziona, ma a volte ottengo:

Optional(Error Domain=NSCocoaErrorDomain Code=3840 "The operation couldn’t be completed. (Cocoa error 3840.)" (Invalid value around character 0.) UserInfo=0x78e74b80 {NSDebugDescription=Invalid value around character 0.})

Ho letto che ciò può essere dovuto a un JSON non valido, ma la risposta è una stringa json statica che ho convalidato nel validatore JSON come valida. Contiene caratteri å ä ö e un po 'di HTML.

Perché a volte ricevo questo errore?

Ho anche affrontato lo stesso problema. Ho provato responseStringinvece di responseJSONe ha funzionato. Immagino che questo sia un bug Alamofirenell'usarlo con django.

Ho ricevuto lo stesso errore durante il caricamento dell'immagine in formato multiparte in Alamofire mentre stavo usando

multipartFormData.appendBodyPart(data: image1Data, name: "file")

ho risolto sostituendo con

multipartFormData.appendBodyPart(data: image1Data, name: "file", fileName: "myImage.png", mimeType: "image/png")

Spero che questo aiuti qualcuno.

Possa questo aiutarti

Alamofire.request(.GET, "YOUR_URL")
     .validate()
     .responseString { response in
         print("Success: \(response.result.isSuccess)")
         print("Response String: \(response.result.value)")
     }

Lo stesso problema è accaduto a me e in realtà è finito per essere un problema del server poiché il tipo di contenuto non era impostato.

Aggiunta

.validate(contentType: ["application/json"])

Per la catena di richieste ha risolto per me

Alamofire.request(.GET, "url")
        .validate(contentType: ["application/json"])
        .authenticate(user: "", password: "")
        .responseJSON() { response in
            switch response.result {
            case .Success:
                print("It worked!")
                print(response.result.value)
            case .Failure(let error):
                print(error)
            }
        }

Nel mio caso, l'URL del mio server non era corretto. Controlla l'URL del tuo server !!

Ho ricevuto lo stesso errore. Ma ho trovato la soluzione.

NOTA 1: "Non è un errore di Alarmofire", è causa di un errore del server.

NOTA 2: non è necessario modificare "responseJSON" in "responseString".

public func fetchDataFromServerUsingXWWWFormUrlencoded(parameter:NSDictionary, completionHandler: @escaping (_ result:NSDictionary) -> Void) -> Void {

        let headers = ["Content-Type": "application/x-www-form-urlencoded"]
        let completeURL = "http://the_complete_url_here"
        Alamofire.request(completeURL, method: .post, parameters: (parameter as! Parameters), encoding: URLEncoding.default, headers: headers).responseJSON { response in

            if let JSON = response.result.value {
                print("JSON: \(JSON)") // your JSONResponse result
                completionHandler(JSON as! NSDictionary)
            }
            else {
                print(response.result.error!)
            }
        }
    }

In questo modo sono riuscito a risolvere l'errore 3840 non valido.

Il registro degli errori

 responseSerializationFailed(Alamofire.AFError.ResponseSerializationFailureReason.jsonSerializationFailed(Error Domain=NSCocoaErrorDomain Code=3840 "Invalid value around character 0." UserInfo={NSDebugDescription=Invalid value around character 0.}))

1. Era con il tipo di codifica utilizzato nella richiesta, il tipo di codifica utilizzato dovrebbe essere accettato nel lato server .

Per conoscere la codifica ho dovuto esaminare tutti i tipi di codifica:

default / methodDependent / queryString / httpBody

    let headers: HTTPHeaders = [
        "Authorization": "Info XXX",
        "Accept": "application/json",
        "Content-Type" :"application/json"
    ]

    let parameters:Parameters = [
        "items": [
                "item1" : value,
                "item2": value,
                "item3" : value
        ]
    ]

    Alamofire.request("URL",method: .post, parameters: parameters,encoding:URLEncoding.queryString, headers: headers).responseJSON { response in
        debugPrint(response)
     }

2. Dipende anche dalla risposta che stiamo ricevendo dall'uso appropriato
   • responseString
   • responseJSON
   • responseData

Se la risposta non è un JSON e solo una stringa in risposta, utilizzare responseString

Esempio : in caso di login / creazione di token API:

"20dsoqs0287349y4ka85u6f24gmr6pah"

responseString

Ho risolto usando questo come intestazione:

let header = ["Content-Type": "application/json", "accept": "application/json"]

Nel mio caso, c'era un extra / nell'URL.

Forse è troppo tardi ma ho risolto questo problema in un altro modo non menzionato qui:

Quando lo usi .responseJSON(), devi impostare l'intestazione della risposta con content-type = application/json, in caso contrario, si bloccherà anche se il tuo corpo è un JSON valido. Quindi, forse l'intestazione della risposta è vuota o utilizza un altro tipo di contenuto.

Assicurati che la tua intestazione di risposta sia impostata con content-type = application/jsona .responseJSON()in Alamofire funziona correttamente.

Ehi ragazzi, questo è quello che ho trovato essere il mio problema: stavo chiamando Alamofire tramite una funzione per autenticare gli utenti: ho usato la funzione "Login utente" con i parametri che sarebbero stati chiamati dal "corpo" (email: String, password: String) Sarebbe passato

il mio errore era esattamente:

opzionale (alamofire.aferror.responseserializationfailed (alamofire.aferror.responseserializationfailurereason.jsonserializationfailed (error domain = nscocoaerrordomain code = 3840 "valore non valido attorno al carattere 0." userinfo = {nsdebugdescription = valore non valido intorno al carattere 0

il carattere 0 è la chiave qui: significa che la chiamata per l '"email" non corrispondeva ai parametri: vedere il codice sotto

func loginUser (email: String, password: String, complete: @escaping downloadComplete) {let lowerCasedEmail = email.lowercased ()

    let header = [
        "Content-Type" : "application/json; charset=utf-8"
    ]
    let body: [String: Any] = [
        "email": lowerCasedEmail,
        "password": password
    ]

    Alamofire.request(LOGIN_USER, method: .post, parameters: body, encoding: JSONEncoding.default, headers: header).responseJSON { (response) in
        if response.result.error == nil {

            if let data = response.result.value as? Dictionary<String, AnyObject> {
                if let email = data["user"] as? String {
                    self.userEmail = email
                    print(self.userEmail)
                }
                if let token = data["token"] as? String {
                    self.token_Key = token
                    print(self.token_Key)
                }

"email" nei parametri della funzione deve corrispondere a let "email" durante l'analisi, quindi funzionerà .. Non ho più ricevuto l'errore ... E il carattere 0 era l '"email" nel parametro "body" per la richiesta Alamofire:

Spero che questo ti aiuti

Stavo inviando il tipo improprio (String) al server nei miei parametri (doveva essere un Int).

L'errore è stato risolto dopo aver aggiunto la codifica: JSONEncoding.default con Alamofire.

  Alamofire.request(urlString, method: .post, parameters: 
  parameters,encoding: 
  JSONEncoding.default, headers: nil).responseJSON {  
   response in
   switch response.result {
                   case .success:
                    print(response)
                    break

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

L'applicazione su cui stavo lavorando questa mattina ha avuto lo stesso errore. Ho creduto che fosse un errore lato server poiché non ero in grado di caricare un'immagine utente.

Tuttavia, dopo aver controllato la mia API personalizzata, mi sono reso conto che dopo aver aggiunto un certificato SSL al mio sito Web che non avevo aggiornato gli URL api.swift, i dati non erano in grado di pubblicare:

let HOME_URL = "http://sitename.io"
let BASE_URL = "http://sitename.io/api"
let UPLOAD_URL = "http://sitename.io/api/user/upload"

Ho cambiato l'URL in https: //. Problema risolto.

Nel mio caso devo aggiungere questa chiave: "Accept": "application / json" alla mia richiesta di intestazione.

Qualcosa come questo:

let Auth_header: [String:String] = ["Accept":"application/json", "Content-Type" : "application/json", "Authorization":"Bearer MyToken"]

Spero che questo possa aiutare qualcuno.

Affronto lo stesso problema e il problema è in params.

let params = [kService: service,
                  kUserPath: companyModal.directory_path,
                  kCompanyDomain: UserDefaults.companyDomain,
                  kImageObject: imageString,
                  kEntryArray: jsonString,
                  kUserToken:  UserDefaults.authToken] as [String : Any]

companyModal.directory_pathè url. è passato dalla stringa a qualsiasi cosa che crei problemi sul lato server. Per risolvere questo problema devo fornire un valore predefinito che lo rende un valore stringa.

 let params = [kService: kGetSingleEntry,
                  kUserPath: companyModal.directory_path ?? "",
                  kCompanyDomain: UserDefaults.companyDomain,
                  kUserToken: UserDefaults.authToken,
                  kEntryId: id,
                  ] as [String: Any]

Probabilmente hai "/" alla fine del tuo percorso. Se non è una richiesta GET, non dovresti mettere "/" alla fine, altrimenti otterrai l'errore

Ho cambiato mimeType da "mov" a "multipart / form-data".

Alamofire.upload(multipartFormData: { (multipartFormData) in
            do {
                let data = try Data(contentsOf: videoUrl, options: .mappedIfSafe)
                let fileName = String(format: "ios-video_%@.mov ", profileID)
                multipartFormData.append(data, withName: "video", fileName: fileName, mimeType: "multipart/form-data")

            } catch  {
                completion("Error")
            }
        }, usingThreshold: .init(), to: url,
           method: .put,
           headers: header)

Ha funzionato per me .. :)

Per il mio caso:

let header = ["Authorization": "Bearer \(Authserices.instance.tokenid)"]

Ho dimenticato lo spazio prima \(dopo Bearer)

Nel mio caso l'errore era dovuto alla duplicazione dell'email. Puoi ricontrollare la tua API su Postman per vedere se la risposta è OK o no.