web-dev-qa-db-fra.com

Traitement du délai d'attente avec Alamofire

Est-il possible d'ajouter un gestionnaire de délai d'attente pour la demande Alamofire?

Dans mon projet, j'utilise Alamofire de la manière suivante:

init() {
    let configuration = NSURLSessionConfiguration.defaultSessionConfiguration()
    configuration.timeoutIntervalForRequest = 30

    self.alamofireManager = Alamofire.Manager(configuration: configuration)
}

func requestAuthorizationWithEmail(email:NSString, password:NSString, completion: (result: RequestResult) -> Void) {

    self.alamofireManager!.request(.POST, "myURL", parameters:["email": email, "password":password])
        .responseJSON { response in
            switch response.result {
            case .Success(let JSON):
                //do json stuff
            case .Failure(let error):
                print("\n\nAuth request failed with error:\n \(error)")
                completion(result: .ConnectionFailed)
            }
    }
}

MODIFIER:

demande échec message

Domaine d'erreur = Code NSURLErrorDomain = -1001 "La demande a expiré." UserInfo = {NSUnderlyingError = {0x7fc10b937320 erreur Domaine = UserInfo = {_ kCFStreamErrorCodeKey = -2102, _kCFStreamErrorDomainKey = 4}} = code kCFErrorDomainCFNetwork -1001 "(null)", NSErrorFailingURLStringKey = url, NSErrorFailingURLKey = url, _kCFStreamErrorDomainKey = 4, _kCFStreamErrorCodeKey = -2102 , NSLocalizedDescription = La requête a expiré.}

swiftalamofire
30
IgorNikolaev

Vous pouvez comparer error.code et s'il est égal à -1001 qui est NSURLErrorTimedOut, alors vous savez qu'il s'agissait d'un délai d'attente.

Swift 3, Alamofire 4.0.1

let manager = Alamofire.SessionManager.default
manager.session.configuration.timeoutIntervalForRequest = 120

manager.request("yourUrl", method: .post, parameters: ["parameterKey": "value"])
        .responseJSON {
            response in
            switch (response.result) {
            case .success:
                //do json stuff
                break
            case .failure(let error):
                if error._code == NSURLErrorTimedOut {
                    //HANDLE TIMEOUT HERE
                }
                print("\n\nAuth request failed with error:\n \(error)")
                break
            }
        }

Swift 2.2

self.alamofireManager!.request(.POST, "myURL", parameters:["email": email, "password":password])
.responseJSON { response in
    switch response.result {
        case .Success(let JSON):
            //do json stuff
        case .Failure(let error):
            if error._code == NSURLErrorTimedOut {
               //HANDLE TIMEOUT HERE
            }
         print("\n\nAuth request failed with error:\n \(error)")
         completion(result: .ConnectionFailed)
     }
}
71
kamwysoc

Swift 3

La réponse acceptée n'a pas fonctionné pour moi.

Après beaucoup de recherches, j'ai fait comme ça.

let manager = Alamofire.SessionManager.default
manager.session.configuration.timeoutIntervalForRequest = 120

manager.request("yourUrl", method: .post, parameters: ["parameterKey": "value"])
19
Anil Kukadeja

Swift 3, Alamofire 4.5.0

Je voulais définir le même délai d'attente pour chaque appel HTTP de mon projet.

L'idée principale est de déclarer le Alamofire Session Manager en tant que variable globale . Ensuite, pour créer une variable URLSessionConfiguration, définissez son délai d'expiration en secondes et affectez-la au gestionnaire.

Chaque appel du projet peut utiliser ce gestionnaire de session configuré. 

Dans mon cas, la variable globale Alamofire Session Manager a été définie dans le fichier AppDelegate (globalement) et sa configuration a été gérée dans sa méthode didFinishLaunchingWithOptions

AppDelegate.Swift 

import UIKit

var AFManager = SessionManager()

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {

        let configuration = URLSessionConfiguration.default
        configuration.timeoutIntervalForRequest = 4 // seconds
        configuration.timeoutIntervalForResource = 4 //seconds
        AFManager = Alamofire.SessionManager(configuration: configuration)

        return true
    }
    ...
}

A partir de maintenant, la fonction demande Alamofire peut être appelée à partir de n’importe quelle partie de l’application à l’aide de afManager.

Par exemple:

AFManager.request("yourURL", method: .post, parameters: parameters, encoding: JSONEncoding.default).validate().responseJSON { response in
    ...
}
9
ivoroto

Swift 3.x  

class NetworkHelper {
    static let shared = NetworkHelper()
    var manager: SessionManager {
        let manager = Alamofire.SessionManager.default
        manager.session.configuration.timeoutIntervalForRequest = 10
        return manager
    }
    func postJSONData( withParams parameters: Dictionary<String, Any>, toUrl urlString: String, completion: @escaping (_ error: Error,_ responseBody: Dictionary<String, AnyObject>?)->()) {
        manager.request(urlString, method: .post, parameters: parameters, encoding: JSONEncoding.default).responseJSON { response in 
            if let error = response.result.error {
                if error._code == NSURLErrorTimedOut {
                    print("Time out occurs!")
                }
            }
        }
    }
}
4
Gurjit Singh

Swift 3.x

La réponse acceptée n'a pas fonctionné pour moi aussi.

Ce travail pour moi! 

let url = URL(string: "yourStringUrl")!
var urlRequest = URLRequest(url: url)
urlRequest.timeoutInterval = 5 // or what you want

Et après:

Alamofire.request(urlRequest).response(completionHandler: { (response) in
    /// code here
}
1
ventuz

Swift 4

Cette fonctionnalité est pratique et pratique, en attendant, elle pratique singleton pour les classes d'api . Reference from here

class Auth {
    static let api = Auth()
    private var alamoFire: SessionManager?

    private init() {}

    func headers() -> HTTPHeaders {
        return [
            "Accept": "XXX",
            "Authorization": "XXX",
            "Content-Type": "XXX"
        ]
    }

    func alamofireConfig(timeout lhs: TimeInterval) {
        let configuration = URLSessionConfiguration.default
        configuration.timeoutIntervalForRequest = lhs
        configuration.timeoutIntervalForResource = lhs
        alamoFire = Alamofire.SessionManager(configuration: configuration, delegate: SessionDelegate(), serverTrustPolicyManager: nil)
    }

    func querySample() {

        alamofireConfig(timeout: 10)
        alamoFire?.request("api_post_url", method: .post, parameters: ["parametersKey": "value"], encoding: JSONEncoding.default, headers: headers())
            .responseJSON(completionHandler: { (response) in
            switch response.result {
            case .success(let value):
                // do your statement
            case .failure(let error):
                if error._code == NSURLErrorTimedOut {
                    // timeout error statement
                } else {
                    // other error statement
                }
            }
        })
    }

    func queryOtherSample() {

        alamofireConfig(timeout: 5)
        alamoFire?.request("api_get_url", method: .get, parameters: nil, encoding: JSONEncoding.default, headers: headers())
            .responseJSON(completionHandler: { (response) in
            switch response.result {
            case .success(let value):
                // do your statement
            case .failure(let error):
                if error._code == NSURLErrorTimedOut {
                    // timeout error statement
                } else {
                    // other error statement
                }
            }
        })
    }

}
0
Joshpy