Swift: асинхронный обратный вызов

Ответ 1

Я поделился шаблоном, который я использую для этого сценария, в следующем виде: https://gist.github.com/szehnder/84b0bd6f45a7f3f99306

В принципе, я создаю singleton DataProvider.swift, который настраивает клиента AFNetworking. Затем контроллеры View Controls обрабатывают этот DataProvider, каждый из которых заканчивается закрытием, которое я определил как typealias, называемый ServiceResponse. Это закрытие возвращает либо словарь, либо ошибку.

Это позволяет вам очень чисто (imo) вызывать действие асинхронных данных из VC с очень четким указанием того, что вы хотите выполнить, когда возвращается ответ async.

DataProvider.swift

typealias ServiceResponse = (NSDictionary?, NSError?) -> Void

class DataProvider: NSObject {

    var client:AFHTTPRequestOperationManager?
    let LOGIN_URL = "/api/v1/login"

    class var sharedInstance:DataProvider {
        struct Singleton {
            static let instance = DataProvider()
        }
        return Singleton.instance
    }

    func setupClientWithBaseURLString(urlString:String) {
        client = AFHTTPRequestOperationManager(baseURL: NSURL.URLWithString(urlString))
        client!.operationQueue = NSOperationQueue.mainQueue()
        client!.responseSerializer = AFJSONResponseSerializer()
        client!.requestSerializer = AFJSONRequestSerializer()
    }

    func loginWithEmailPassword(email:String, password:String, onCompletion: ServiceResponse) -> Void {
        self.client!.POST(LOGIN_URL, parameters: ["email":email, "password":password] , success: {(operation:AFHTTPRequestOperation!, responseObject:AnyObject!) -> Void in

            self.setupClientWithBaseURLString("http://somebaseurl.com")

            let responseDict = responseObject as NSDictionary
                // Note: This is where you would serialize the nsdictionary in the responseObject into one of your own model classes (or core data classes)
                onCompletion(responseDict, nil)
            }, failure: {(operation: AFHTTPRequestOperation!, error:NSError!) -> Void  in
                onCompletion(nil, error)
            })
    }
}

MyViewController.swift

import UIKit

class MyViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view.
    }

    override func viewWillAppear(animated: Bool)  {
        super.viewWillAppear(animated)
        DataProvider.sharedInstance.loginWithEmailPassword(email:"[email protected]", password:"somepassword") { (responseObject:NSDictionary?, error:NSError?) in

            if (error) {
                println("Error logging you in!")
            } else {
                println("Do something in the view controller in response to successful login!")
            }
        }
    }  
}

Ответ 2

Я бы рекомендовал использовать обратный вызов блока или замыкания вместо использования NSThread и селекторов.

Например, в моем API я следую методу:

Swift:

Ниже вы найдете обновленную реализацию.

func getUsers(completion: (result: NSArray?, error: NSError?)->())
{
    var session = NSURLSession.sharedSession()
    var task = session.dataTaskWithRequest(request){
     (data, response, error) -> Void in
       if error != nil {
         completion(nil, error)
       } else {
         var result:NSArray = data to NSArray;
         completion(result, nil)
       }
    }
    task.resume()
}

Objective-C:

...
typedef void (^CBSuccessBlock)(id result);
typedef void (^CBFailureBlock)(NSError *error);
...

- (void)usersWithSucces:(CBSuccessBlock)success failure:(CBFailureBlock)failure
{
    NSURLSession *session = [NSURLSession sharedSession];
    [[session dataTaskWithURL:[NSURL URLWithString:url]
            completionHandler:^(NSData *data,
                                NSURLResponse *response,
                                NSError *error) {

                NSArray *users = //convert data to array

                if(error)
                    failure(error);
                else
                    success(users);
            }] resume];
}

Затем просто вызовите api из контроллера вида:

Objc:
[api usersWithSucces:^(id result)
{
   //Success callback
} failure:^(NSError *error)
{
   //Failure callback
}];

Swift:
api.getUsers({(result: AnyObject?, error: NSError?) -> Int in
    // callback here
})

UPDATE:

Между тем, я вижу, что вопрос и ответы по-прежнему полезны и интересны. Ну, вот обновленная версия быстрой реализации с использованием общего перечисления в качестве объекта результата:

//Generic enum that represents the result
enum AsyncResult<T>
{
    case Success(T)
    case Failure(NSError?)
}


class CustomUserObject
{

}

func getUsers(completion: (AsyncResult<[CustomUserObject]>)->())
{
    let request = NSURLRequest()
    let session = NSURLSession.sharedSession()
    let task = session.dataTaskWithRequest(request){
        (data, response, error) -> Void in
        if let error = error
        {
            completion(AsyncResult.Failure(error))
        } else {
            let result: [CustomUserObject] = []//deserialization json data into array of [CustomUserObject]
            completion(AsyncResult.Success(result))
        }
    }
    task.resume()
}

//Usage:

getUsers { (result) in
    switch result
    {
    case .Success(let users):
        /* work with users*/
        break
    case .Failure(let error):
        /* present an error */
        break
    }
}

Ответ 3

Я только что сделал этот маленький пример: Swift: пример шаблона обратного вызова Async

В основном существует ClassA:

//ClassA it the owner of the callback, he will trigger the callback when it the time
class ClassA {
    //The property of that will be associated to the ClassB callback
    var callbackBlock : ((error : NSError?, message : String?, adress : String? ) -> Void)?

    init() {
        //Do Your staff
    }

    //Define your function with the clousure as a parameter
    func yourFunctionWithCallback(#functionCallbackParameter : (error : NSError?,message : String?, adress : String?) -> ()) {
        //Set the calback with the calback in the function parameter
        self.callbackBlock = functionCallbackParameter
    }

    //Later On..
    func callbackTrigger() {
        self.callbackBlock?(error: nil,message: "Hello callback", adress: "I don't know")

    }
}

И ClassB:

//ClassB it the callback reciver the callback
class ClassB {
    @IBAction func testCallbackFunction(sender: UIButton) {
        let classA = ClassA()
        classA.yourFunctionWithCallback { (error, message, adress) -> () in
            //Do your stuff
        }
    }
}

ClassA:, которому принадлежит свойство witch - callbackBlock. ClassB будет устанавливать это свойство, вызывая функцию yourFunctionWithCallback. Позже, тогда ClassA готов, вызовет обратный вызов, вызвав callBackBlock внутри функции callbackTrigger.

ClassB: вызовет метод ClassA для установки блока обратного вызова и дождитесь, пока блок не будет запущен.

Ответ 4

Может ли NSThread помочь вам?:

NSThread.detachNewThreadSelector(<#selector: Selector#>, toTarget: <#AnyObject?#>, withObject: <#AnyObject?#>)