Swift: Asynchronous callback

I've shared the pattern that I use for this scenario in the following gist: https://gist.github.com/szehnder/84b0bd6f45a7f3f99306

Basically, I create a singleton DataProvider.swift that setups an AFNetworking client. Then the View Controllers call methods on that DataProvider, each of which is terminated by a closure that I've defined as a typealias called ServiceResponse. This closure returns either a dictionary or an error.

It allows you to very cleanly (imo) call for an async data action from the VC's with a very clear indication of what you want performed when that async response returns.

DataProvider.swift

typealias ServiceResponse = (NSDictionary?, NSError?) -> Voidclass 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 UIKitclass 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:"some@email.com", 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!")            }        }    }  }

I'd like to recommend use a block or closure callback instead of using NSThread and selectors.

For example, in my API I have follow method:

Swift:

Below you will find an updated implementation.

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];}

Then, just make a call to api from view controller:

Objc:[api usersWithSucces:^(id result){   //Success callback} failure:^(NSError *error){   //Failure callback}];Swift:api.getUsers({(result: AnyObject?, error: NSError?) -> Int in    // callback here})

UPDATE:

Meanwhile, I see that the question and answers are still being useful and interested. Well, here is an updated version of swift implementation using generic enum as a result object:

//Generic enum that represents the resultenum 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    }}

I've just made this little example:Swift: Async callback block pattern example

Basically there is ClassA:

//ClassA it's the owner of the callback, he will trigger the callback when it's the timeclass 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")    }}

And ClassB:

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

ClassA: it's the owns a property witch is the callbackBlock. ClassB will set this property by Call the yourFunctionWithCallback function. Later on then ClassA it's ready, will trigger the callback by calling the callBackBlock inside the callbackTrigger function.

ClassB: will call the ClassA method to set the callback block and wait until the block has been triggered.