Wait until NSURLConnection sendAsynchronousRequest is finished

Question

I have the following problem. I have a Model, called User. When the user now logins with Facebook, my app checks if the user exists already in the database. To not freeze the UI (since I'm coming from Android) I thought to use `NSURLConnection sendAsynchronousRequest`. What worked at first was the following: My User Model had a method to do the whole task of the `AsynchronousRequest` and then when finished would set a variable to loading. Then other classes, could simply check with `while ( !user.loading )` if the Request was finished or not. The problem that came here to me, was, that now, I had to put this method in every Model. So instead of this, I created a new Class `HTTPPost`. This class now has the method that gets an `NSDictionary` passed and returns one. This works ALMOST. The problem I was now encountering is, that I couldn't really determine if the process was finished or not. So I started to create a new class called `Globals` and use global Variable `loading`. But the gl…

Accepted Answer

It seems that you're trying to take an asynchronous process (`sendAsynchronousRequest`) , and make it behave like a synchronous process (i.e. you appear to want to wait for it). You should not do that. You should to embrace the asynchronous patterns rather than fighting them.

The `sendAsynchronousRequest` method has a completion block that specifies what you want to do when the request is done. Do not try to put the code after the block and (try to) wait for the block to complete, but rather put any of your code that is dependent upon the completion of the network request inside the completion block, or have the completion block call your code.

A common way would be to give your own methods their own completion blocks and then call those blocks in the `completionHandler` of `sendAsynchronousRequest`, something like:

```
- (void)performHttpRequest:(NSDictionary *)postDict completion:(void (^)(NSDictionary *dictionary, NSError *error))completion
{
    // prepare the request

// now issue the request

[NSURLConnection sendAsynchronousRequest:request queue:[NSOperationQueue mainQueue] completionHandler:^(NSURLResponse *response, NSData *data, NSError *error) {
        if (error) {
            if (completion)
                completion(data, error);
        } else {
            NSString *responseBody = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
            returnDict             = [NSJSONSerialization JSONObjectWithData:data
                                                                     options: NSJSONReadingMutableContainers
                                                                      error: &error];
            if (completion)
                completion(returnDict, error);
    }];
}
```

Now, when you want to perform your request, you simply do:

```
[self performHttpRequest:someDictionary completion:^(NSDictionary *dictionary, NSError *error) {
    if (error) {
        // ok, handle the error here
    } else {
        // ok, use the `dictionary` results as you see fit here
    }
];
```

Note, the method that calls this `performHttpRequest` (let's imagine you called it from `loadModelFrom `) now behaves asynchronously, itself. So you might want to employ this completion-block pattern again, e.g. adding your own `completion` block parameter to `loadModelFrom`, and then invoke that block in the completion handler `loadModelFrom` passes to `performHttpRequest`.

But hopefully you get the idea: Never try to wait for a completion block, but rather just put inside that block anything you want it to do when its done. Whether you use AFNetworking (which I'd advise), or continue to use `sendAsynchronousRequest`, this is a very useful pattern with which you should become familiar.

Update:

The revised code sample (largely) works great for me. Seeing your revised question, a couple of observations:

I am not familiar with this `base64EncodedString` method. In iOS 7, there is the native `base64EncodedStringWithOptions` method (or for earlier iOS versions use `base64Encoding`). Or are you using a third party base-64 `NSData` category?

There's no point in creating `jsonString`, only to then convert it back to a `NSData`. Just use `jsonData` in your request.

The same is true with `responseBody`: Why convert to string only to convert back to `NSData`?

There's no point in having `returnDict` to be defined as `__block` outside the `sendAsynchronousRequest` block. Just define it inside that block and the `__block` qualifier is then no longer necessary.

Why create a `NSOperationQueue` for the `completionHandler` of `sendAsynchronousRequest`? Unless I'm doing something really slow that merits running on a background queue, I just use `[NSOperationQueue mainQueue]`, because you invariably want to update the app's model or UI (or both), and you want to do that sort of stuff on the main queue.

The request still runs asynchronously but the `queue` parameter just specifies which queue the completion block will run on.

By the way, in `sendAsynchronousRequest`, you aren't checking to see if the request succeeded before proceeding with `JSONObjectWithData`. If the request failed, you could theoretically be losing the `NSError` object that it returned. You really should check to make sure the request succeeded before you try to parse it.

Likewise, when you originally `dataWithJSONObject` the parameters in `postDict`, you really should check for success, and if not, report the error and quit.

I notice that you're using the `NSJSONReadingMutableContainers` option. If you really need a mutable response, I'd suggest making that explicit in your block parameters (replacing all the `NSDictionary` references with `NSMutableDictionary`). I assume you don't really need it to be mutable, so I therefore recommend removing the `NSJSONReadingMutableContainers` option.

Likewise, when creating the JSON, you don't need to use the `NSJSONWritingPrettyPrinted` option. It only makes the request un…

Wait until NSURLConnection sendAsynchronousRequest is finished

Solution

Problem