Führen Sie nach der Anfrage in iOS Swift

Gibt es eine ganze Reihe von taktischen Fragen hier:

1. Erstellen Sie NSURLSession, aber dann die Ausgabe NSURLConnection Anfrage. Wählen Sie eine oder das andere (Sie könnte genauso gut verwenden NSURLSession).

2. Ihre "Wunsch-Wörterbuch" ist kein Lexikon, sondern ein array. Zum Beispiel zur Ausgabe der JSON-RPC-Anfrage das richtige format des Wörterbuchs ist:

   let requestDictionary = [
       "jsonrpc" : "2.0",
       "id"      : 1,
       "method"  : "login",
       "params"  : ["myuserid", "mypassword", "mykey"]
   ]

3. Kleinere Problem, aber Sie verwenden eine Menge von Variablen (über var), wo eine Konstante (über let) wäre fein. In den Geist der Swift-Sicherheit, verwenden Sie let wo immer möglich.

4. Entsprechend der Lacuna Expanse API, Ihre URL sollte, einschließlich den Namen des Moduls.

   So, zum Beispiel, wenn dabei POST Anforderungen in der "Empire" - Modul, die URL ist:

   let url = NSURL(string: "https://us1.lacunaexpanse.com/empire")

5. Werden Sie wahrscheinlich zu tun eine Menge von Anfragen, so würde ich empfehlen, den größten Teil des in einer einzigen Funktion, die Sie aufrufen können, wieder und wieder, ohne sich wiederholende code alle über dem Platz. Vielleicht eine Funktion wie die folgende, die folgenden Parameter:

   • Modul (z.B. "Reich" gegen "Allianz");

   • Methode (z.B. "login" vs "fetch_captcha");

   • die geeigneten Parameter für die Anforderung (z.B. für "login", das wäre der "name", "Passwort", und die "api_key"); und

   • Schließung, die wird aufgerufen, wenn die asynchrone Anforderung abgeschlossen ist.

   Diese Funktion bereitet die JSON-RPC Anfrage und fordert die Schließung, wenn die Anfrage beendet:

   func submitLacunaRequestFromModule(module: String, method: String, parameters: AnyObject, completion: (AnyObject?, NSError?) -> ()) -> NSURLSessionTask? {
       let session = NSURLSession.sharedSession()
       let url = NSURL(string: "https://us1.lacunaexpanse.com")!.URLByAppendingPathComponent(module)
       let request = NSMutableURLRequest(URL: url)
       request.HTTPMethod = "POST"
       request.setValue("application/json-rpc", forHTTPHeaderField: "Content-Type")
   
       let requestDictionary = [
           "jsonrpc" : "2.0",
           "id"      : 1,
           "method"  : method,
           "params"  : parameters
       ]
   
       request.HTTPBody = try! NSJSONSerialization.dataWithJSONObject(requestDictionary, options: [])
   
       let task = session.dataTaskWithRequest(request) { data, response, error in
   
           //handle fundamental network errors (e.g. no connectivity)
   
           guard error == nil && data != nil else {
               completion(data, error)
               return
           }
   
           //check that http status code was 200
   
           if let httpResponse = response as? NSHTTPURLResponse where httpResponse.statusCode != 200 {
               completion(String(data: data!, encoding: NSUTF8StringEncoding), nil)
           }
   
           //parse the JSON response
   
           do {
               let responseObject = try NSJSONSerialization.JSONObjectWithData(data!, options: []) as? NSDictionary
               completion(responseObject, nil)
           } catch let error as NSError {
               completion(String(data: data!, encoding: NSUTF8StringEncoding), error)
           }
       }
       task.resume()
   
       return task
   }

   Dieser hat alle von der notwendigen Verpackung der Methode und Parameter in eine JSON-RPC Anfrage. Dann, alles, was Sie tun müssen, um zu rufen, die Methode ist etwas wie so:

   submitLacunaRequestFromModule("empire", method: "login", parameters: ["myuserid", "mypassword", "mykey"]) { responseObject, error in
   
       //some network error or programming error
   
       guard error == nil else {
           print("error = \(error)")
           print("responseObject = \(responseObject)")
           return
       }
   
       //network request ok, now see if login was successful
   
       if let responseDictionary = responseObject as? NSDictionary {
           if let errorDictionary = responseDictionary["error"] as? NSDictionary {
               print("error logging in (bad userid/password?): \(errorDictionary)")
           } else if let resultDictionary = responseDictionary["result"] as? NSDictionary {
               print("successfully logged in, refer to resultDictionary for details: \(resultDictionary)")
           } else {
               print("we should never get here")
               print("responseObject = \(responseObject)")
           }
       }
   }

   Für eine Anfrage, die erfordert, dass ein Wörterbuch, wie "erstellen", gehen Sie einfach weiter und liefern Wörterbuch:

   submitLacunaRequestFromModule("empire", method: "create", parameters: [
       "name"      : "user",
       "password"  : "password",
       "password1" : "password",
       "captcha_guid" : "305...dd-....-....-....-e3706...73c0",
       "captcha_solution" : "42",
       "email" : "[email protected]"
       ]) { responseObject, error in
   
           guard error == nil else {
               print("error = \(error)")
               print("responseObject = \(responseObject)")
               return
           }
   
           print("responseObject = \(responseObject)")
   }

Klar, in diese über, ich mache nur minimale Fehlerbehandlung, so könnte man Rindfleisch, aber deine Frage war über die Ausgabe POST Anfrage, und hoffentlich die oben zeigt, wie ' s gemacht wird.

InformationsquelleAutor Rob