AFNetworking nested calll [closed] - iphone

Question

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions concerning problems with code you've written must describe the specific problem — and include valid code to reproduce it — in the question itself. See SSCCE.org for guidance.
Closed 9 years ago.
Improve this question
Right now, I got a GET request, after it's finished, I got the json back, and then I want to use the id from the json to execute another fetch request. It's like a nested fetch request right after another. For example:
+ (void)searchPhotoWithTags:(NSArray *)tags page:(NSInteger)page perPage:(NSInteger)perPage completionBlock:(void (^)(NSArray *, NSError *))block
{
NSDictionary *dict = #{#"method": #"search", #"api_key": kAppKey, #"tags": [tags componentsJoinedByString:#","], #"per_page": [NSString stringWithFormat:#"%d", perPage], #"page": [NSString stringWithFormat:#"%d", page], #"format": #"json"};
[[LDHttpClient sharedClient] getPath:#"" parameters:dict success:^(AFHTTPRequestOperation *operation, id responseObject) {
[[responseObject valueForKeyPath:#"photos.photo"] enumerateObjectsUsingBlock:^(id obj, NSUInteger idx, BOOL *stop) {
Photo *photo = [[Photo alloc] initWithPhotoId:[NSNumber numberWithInt:[obj[#"id"] integerValue]] andSecret:obj[#"secret"]];
//down below, I want to use photo.photoId to execute another request but the data is not completed. what's the better way to do this?
[PhotoSize getPhotoSizesWithPhotoId:photo.photoId completionBlock:^(NSArray *photoSizes, NSError *error) {
[photos addObject:#{#"photo": photo, #"sizes": photoSizes}];
}];
}];
} failure:^(AFHTTPRequestOperation *operation, NSError *error) {
}];
}

Answer 1

If I understood your question correctly, I think what you're witnessing is a problem of asynchronous.
You are trying to loop through your photos dictionary, getting the photo size of each photo by means of sending another GET request which is an asynchronous operation. However, because of that, the next iteration of your loop already executes before your previous asynchronous operation has finished.
In this case, what you can do is use recursion to help you "iterate" or "loop" through your photos dictionary.
Requirements
For the below code to work, you'll need to create 2 properties
A property for storing your "photos" NSDictionary (e.g. NSDictionary *photosDict) in yourClass.h file
Another property for storing the enumerator of "photos" NSDictionary, which will be of type NSEnumerator, maybe call it "photosEnum"
Cleaning up your code a bit
In your original method, store the photos dictionary and from that, store the photosEnum enumerator too:
+ (void)searchPhotoWithTags:(NSArray *)tags page:(NSInteger)page perPage:(NSInteger)perPage completionBlock:(void (^)(NSArray *, NSError *))block
{
NSDictionary *dict = #{#"method": #"search", #"api_key": kAppKey, #"tags": [tags componentsJoinedByString:#","], #"per_page": [NSString stringWithFormat:#"%d", perPage], #"page": [NSString stringWithFormat:#"%d", page], #"format": #"json"};
[[LDHttpClient sharedClient] getPath:#"" parameters:dict success:^(AFHTTPRequestOperation *operation, id responseObject) {
// I assume you have a property of type NSDictionary created called "photos"
self.photosDict = [responseObject valueForKeyPath:#"photos"];
// Also create a property for the enumerator of type NSEnumerator
self.photosEnum = [self.photosDict objectEnumerator];
// ----------------------------------------------------------
// First call of our recursion method
//
// This will start our "looping" of our photos enumerator
// -----------------------------------------------------------
[self processPhotoDictionary];
} failure:^(AFHTTPRequestOperation *operation, NSError *error) {
NSLog(#"Failed to get photos, error: %#", [error localizedDescription]);
}];
}
And finally, our recursion method does the processing of the photoSizes:
-(void)processPhotoDictionary
{
// ------------------------------------------------------
// Because self.photosEnum is a property of our class
// it remembers where it is "up to" in the "looping"
// ------------------------------------------------------
NSDictionary *photo = [self.photosEnum nextObject];
if(photo != nil)
{
Photo *photoObj = [[Photo alloc] initWithPhotoId:[NSNumber numberWithInt:[[photo valueForKey:#"id"] integerValue]]
andSecret:[photo valueForKey:#"secret"]];
[PhotoSize getPhotoSizesWithPhotoId:photoObj.photoId completionBlock:^(NSArray *photoSizes, NSError *error) {
[photos addObject:#{#"photo": photoObj, #"sizes": photoSizes}];
// ------------------------------------------------------
// Here we're using recursion to iterate through our
// enumerator due to asynchronous nature instead of the
// while loop.
// ------------------------------------------------------
[self processPhotoDictionary];
}];
}
}
Hope that helps.

Answer 2

In addition to the excellent answer of #Zhang, I would like to describe the common problem the OP is facing and how a "general solution" to this common problem may look like.
The common objective is:
Fetch a list of items from a server. Each item contains a URL which points to some other resource (an image for example).
When the list has been received, for each item in the list, fetch the resource (the image) given by the URL.
When implementing this in synchronous style the solution is obvious, and actually quite easy. However, when employing asynchronous style - which is the preferred way when doing networking - a workable solution becomes surprisingly complex, unless you know how to solve such problems ;)
The interesting part here is #2. Part #1 can be simply accomplished via an asynchronous call and a completion function where the completion function invokes part #2.
In order to make the things more easy to understand I will make a few simplifications and a few prerequisites:
In part #1 we obtain a list of elements, say an NSArray object containing our elements. Each element has a property, which is a URL to another resource.
Now, we can easily make the assumption that we already have an array of elements representing the N input values which shall be asynchronously processed in a loop - one after the other. Let us name that array "Source Array".
We will deal with asynchronous methods/functions. One way to have the method/function signal that it is finished with processing something asynchronously is a completion handler (a block).
The common signature for all completion handlers will be defined as follows:
typedef void (^completion_t)(id result);
Note: result shall represent the eventual result of the asynchronous function or method. It may be the kind of thing we expect (an image for example), or it may indicate an error, for example through passing and NSError object.
In oder to implement our part #2, we need an asynchronous method/function which takes an input (one element from the Input Array) and produces an output. This corresponds to your "fetch image resource" task. Later we need to apply this method/function for each element of the "Input Array" we got in part #1.
The generic function, a "transform function", will have this signature:
void transform(id input, completion_t completion);
The corresponding method will have this signature:
-(void) transformWithInput:(id)input
completion:(completion_t)completionHandler;
We can define a typedef for the function as below:
typedef void (^transform_t)(id input, completion_t completion);
Notice, that the result of the transform function or method will be passed through the completion handler's parameter. An synchronous function would just have a return value and return the result.
Note: the name "transform" is just a generic name. You can wrap your network request in a method and get such kind of "transform" function. In the OP's example, the URL would be the input parameter and the completion handler's result parameter would be the image fetched from the server (or an error).
Note: this and the following simplifications are just there to make the explanation of the asynchronous pattern easier to understand. In practice an asynchronous function or method may take other input parameters, and the completion handler may also have other parameters.
Now, the more "tricky" part:
Implementing A Loop In Asynchronous Style
Well, this is a bit "different" than in synchronous programming style.
Purposefully, we define some kind of forEach function or method doing this iteration. That function or method is itself asynchronous! And we know now that any asynchronous function or method will have a completion handler.
So, in case of a function we can declare our "forEach" function as follows:
`void transform_each(NSArray* inArray, transform_t task, completion_t completion);`
transform_each sequentially applies an asynchronous transform function task to each object in the input array inArray. When finished processing all inputs, it invokes the completion handler completion.
The completion handler's result parameter is an array containing the result of each transform function in the same order as the corresponding input.
Note: "sequentially" here means, that the inputs are processed one after the other. A variant of that pattern may process the inputs in parallel.
The parameter inArray is our "Input Array" gathered from step #1.
Parameter task is our asynchronous transform function, which can be virtually anything which takes an input and produces an output. It will be our asynchronous "fetch image" task from the OPs example.
And parameter completion is the handler which gets invoked when all inputs have been processed. It's parameter contains the output of each transform function in an array.
The transform_each can be implemented as follows. First we need a "helper" function do_each.
do_each is actually the heart of the whole pattern for implementing loops in an asynchronous style, so you may take a closer look here:
void do_each(NSEnumerator* iter, transform_t task, NSMutableArray* outArray, completion_t completion)
{
id obj = [iter nextObject];
if (obj == nil) {
if (completion)
completion([outArray copy]);
return;
}
task(obj, ^(id result){
[outArray addObject:result];
do_each(iter, task, outArray, completion);
});
}
The interesting part here, and the "common asynchronous pattern" or "idiom" for implementing loops (as a for_each function) is that do_each will be invoked from the completion handler of the transform function. That may look like a recursion, but actually it is not.
Parameter iter points to the current object within the array which shall be processed.
It will also be used to determine the stop condition: when the enumerator points past the end, we get a nil result from method nextObject. This eventually stops the loop.
Otherwise, the transform function task will be called with the current object as input parameter. The object will be asynchronously processed as defined by the task. When finished, the task's completion handler will be invoked. It's parameter result will be the output of the transform function. The handler needs to add the result to the resulting array outArray. Then it invokes the helper do_each again. This seems to be a recursive call, but it is actually not: the former do_each has already been returned. This is just another invocation of do_each.
Once we have that, we can simply complete our transform_each function as shown below:
void transform_each(NSArray* inArray, transform_t task, completion_t completion) {
NSMutableArray* outArray = [[NSMutableArray alloc] initWithCapacity:[inArray count]];
NSEnumerator* iter = [inArray objectEnumerator];
do_each(iter, task, outArray, completion);
}
NSArray Category
For our convenience we can easily create a Category for NSArray with a "forEach" method which asynchronously processes the inputs in sequence:
#interface NSArray (AsyncExtension)
- (void) async_forEachApplyTask:(transform_t) task completion:(completion_t) completion;
#end
#implementation NSArray (AsyncExtension)
- (void) async_forEachApplyTask:(transform_t) task completion:(completion_t) completion {
transform_each(self, task, completion);
}
#end
A code example can be found here on Gist: transform_each
A much more sophisticated concept to solve common asynchronous patterns is to utilize "Futures" or "Promises". I've implemented the concept of a "Promise" for Objective-C in a small library: RXPromise.
The above "loop" can be implemented including a the capability to cancel the asynchronous tasks via RXPromise, and of course a lot more. Have fun ;)

Answer 3

I think I might just solve this problem. I am not sure about it. It just works. I am using AFNetwroking's enqueueBatchOfHTTPRequestOperations function.