HIGH-LEVEL IOS HTTP APIS

In this section you learn about the high-level APIs most commonly used for HTTP communications from an iOS application to an HTTP server. There are three primary methods to perform HTTP requests and receive responses using the URL loading system:

• Synchronous — The thread on which the initiating code runs blocks until the entire response is loaded and returned to the calling method. This technique is the simplest to implement but has the most limitations.
• Queued asynchronous — The initiating code creates a request and places it on a queue to be performed on a background thread. This method is slightly more difficult to implement and removes a significant limitation of the pure synchronous technique.
• Asynchronous — The initiating code starts a request that runs on the initiating thread but calls delegate methods as the requests proceeds. This technique is the most complicated to implement but provides the most flexibility in handling responses.
• 
  

Three types of requests use a combination of four types of objects: NSURL, NSURLRequest,NSURLConnection, and NSURLResponse.

Synchronous Requests

the example application that performs a synchronous request to load the XML feed.

- (NSArray *) doSyncRequest:(NSString *)urlString {  // make the NSURL object from the string  NSURL *url = [NSURL URLWithString:urlString];     // Create the request object with a 30 second timeout and a   // cache policy to always retrieve the  // feed regardless of cachability.  NSURLRequest *request =   [NSURLRequest requestWithURL:url   cachePolicy:NSURLRequestReloadIgnoringLocalAndRemoteCacheData   timeoutInterval:30.0];     // Send the request and wait for a response  NSHTTPURLResponse *response;  NSError *error = nil;  NSData *data = [NSURLConnection sendSynchronousRequest:request   returningResponse:&response   error:&error];  // check for an error  if (error != nil) {  NSLog(@"Error on load = %@", [error localizedDescription]);  return nil;  }   // check the HTTP status  if ([response isKindOfClass:[NSHTTPURLResponse class]]) {  NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *)response;  if (httpResponse.statusCode != 200) {  return nil;  }  }     // Parse the data returned into an NSDictionary  NSDictionary *dictionary =   [XMLReader dictionaryForXMLData:data   error:&error];  // Dump the dictionary to the log file  NSLog(@"feed = %@", dictionary);     NSArray *entries =[self getEntriesArray:dictionary];     // return the list if items from the feed.  return entries; }

Best Practices for Synchronous Requests

• Only use them on background threads, never on the main thread unless you are completely sure that the request goes to a local file resource.
• Only use them when you know that the data returned will never exceed the memory available to the app. Remember that the entire body of the response is returned in-memory to your code. If the response is large, it may cause out-of-memory conditions in your app. Also remember that your code may duplicate the memory footprint of the returned data when it parses it into a usable format.
• Always validate the error and HTTP response status code returned from the call before processing the returned data.
• Don’t use synchronous requests if the source URL may require authentication, as the synchronous framework does not support responding to authentication requests. The only exception is forBASIC authentication, for which credentials can be passed in the URL or request headers. Performing authentication this way increases the coupling between your app and the server, thereby increasing the fragility of the overall application. It can also pass the credentials in clear text unless the request uses the HTTPS protocol. See Chapter 6, “Securing Network Traffic,” for information on responding to authentication requests.
• Don’t use synchronous requests if you need to provide a progress indicator to the users because the request is atomic and provides no intermediate indications of progress.
• Don’t use synchronous requests if you need to parse the response data incrementally via a stream parser.
• Don’t use synchronous requests if you may need to cancel the request before it is complete.

Queued Asynchronous Requests

- (void) doQueuedRequest:(NSString *)urlString delegate:(id)delegate {  // make the NSURL object  NSURL *url = [NSURL URLWithString:urlString];     // create the request object with a no cache policy and a 30 second timeout.  NSURLRequest *request = [NSURLRequest requestWithURL:url    cachePolicy:NSURLRequestReloadIgnoringLocalAndRemoteCacheData   timeoutInterval:30.0];     // If the queue doesn't exist, create one.  if (queue == nil) {  queue = [[NSOperationQueue alloc] init];  }     // send the request and specify the code to execute when the   // request completes or fails.  [NSURLConnection sendAsynchronousRequest:request   queue:queue   completionHandler:^(NSURLResponse *response,   NSData *data,   NSError *error) {     if (error != nil) {  NSLog(@"Error on load = %@", [error localizedDescription]);  } else {     // check the HTTP status  if ([response isKindOfClass:[NSHTTPURLResponse class]]) {  NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *)response;  if (httpResponse.statusCode != 200) {  return;  }  }     // parse the results and make a dictionary  NSDictionary *dictionary =   [XMLReader dictionaryForXMLData:data   error:&error];  NSLog(@"feed = %@", dictionary);   // get the dictionary entries.  NSArray *entries =[self getEntriesArray:dictionary];   // call the delegate  if ([delegate respondsToSelector:@selector(setVideos:)]) {  [delegate performSelectorOnMainThread:@selector(setVideos:)   withObject:entries   waitUntilDone:YES];  }  }  }];}

Best Practices for Queued Asynchronous Requests

• Only use them when you know that the data returned will never exceed the memory available to the app. The entire body of the response is returned in-memory to your code. If the response is large, it may cause out-of-memory conditions in your app. Remember that your code may duplicate the memory footprint of the returned data when it parses it into a usable format.
• Use a single NSOperationQueue for all your operations and control the maximum number of current operations based on the capacity of your server and the expected network conditions.
• Always validate the error and HTTP response status code returned from the call before processing the returned data.
• Don’t use them if the source URL may require authentication because this functionality does not support responding to authentication requests. You can put BASIC authentication credentials in the URL supplied to the request if the service requires that type of authentication.
• Don’t use queued asynchronous requests if you need to provide a progress indicator to the users because the request is atomic and provides no intermediate indications of progress.
• Don’t use queued asynchronous requests if you need to parse the response data incrementally via a stream parser.
• Don’t use queued asynchronous requests if you may need to cancel the request before it is complete.

Asynchronous Requests

- (void) start {  NSLog(@"Starting to download %@", srcURL);     // create the URL  NSURL *url = [NSURL URLWithString:srcURL];     // Create the request  NSURLRequest *request = [NSURLRequest requestWithURL:url];     // create the connection with the target request and this   // class as the delegate  self.conn =   [NSURLConnection connectionWithRequest:request   delegate:self];     // start the connection  [self.conn start];}

delegate:

- (NSURLRequest *)connection:(NSURLConnection *)connection   willSendRequest:(NSURLRequest *)request   redirectResponse:(NSURLResponse *)redirectResponse {     // Dump debugging information  NSLog(@"Redirect request for %@ redirecting to %@",   srcURL, request.URL);  NSLog(@"All headers = %@",   [(NSHTTPURLResponse*) redirectResponse allHeaderFields]);     // Follow the redirect  return request;}

- (void) connection:(NSURLConnection *)connection  didReceiveResponse:(NSURLResponse *)response {  NSLog(@"Received response from request to url %@", srcURL);     NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *)response;  NSLog(@"All headers = %@", [httpResponse allHeaderFields]);     if (httpResponse.statusCode != 200) {// something went wrong,   //abort the whole thing  // reset the download counts  if (downloadSize != 0L) {  [progressView addAmountToDownload:-downloadSize];  [progressView addAmountDownloaded:-totalDownloaded];  }  [connection cancel];  return;  }     NSFileManager *fm = [NSFileManager defaultManager];     // If we have a temp file already, close it and delete it  if (self.tempFile != nil) {  [self.outputHandle closeFile];     NSError *error;  [fm removeItemAtPath:self.tempFile error:&error];  }   // remove any pre-existing target file  NSError *error;  [fm removeItemAtPath:targetFile error:&error];     // get the temporary directory name and make a temp file name  NSString *tempDir = NSTemporaryDirectory();  self.tempFile = [tempDir stringByAppendingPathComponent:  [self createUUID]];  NSLog(@"Writing content to %@", self.tempFile);     // create and open the temporary file  [fm createFileAtPath:self.tempFile contents:nil attributes:nil];  self.outputHandle = [NSFileHandle fileHandleForWritingAtPath:  self.tempFile];     // prime the download progress view  NSString *contentLengthString = [[httpResponse allHeaderFields]   objectForKey:@"Content-length"];  // reset the download counts  if (downloadSize != 0L) {  [progressView addAmountToDownload:-downloadSize];  [progressView addAmountDownloaded:-totalDownloaded];  }  downloadSize = [contentLengthString longLongValue];  totalDownloaded = 0L;     [progressView addAmountToDownload:downloadSize];}

- (void)connection:(NSURLConnection *)connection   didReceiveData:(NSData *)data {  // figure out how many bytes in this chunk  totalDownloaded+=[data length];     // Uncomment the following lines if you want a packet by   // packet log of the bytes received.    NSLog(@"Received %lld of %lld (%f%%) bytes of data for URL %@",   totalDownloaded,   downloadSize,   ((double)totalDownloaded/(double)downloadSize)*100.0,  srcURL);     // inform the progress view that data is downloaded  [progressView addAmountDownloaded:[data length]];     // save the bytes received  [self.outputHandle writeData:data];}

- (void)connection:(NSURLConnection *)connection   didFailWithError:(NSError *)error {  NSLog(@"Load failed with error %@",   [error localizedDescription]);     NSFileManager *fm = [NSFileManager defaultManager];     // If you have a temp file already, close it and delete it  if (self.tempFile != nil) {  [self.outputHandle closeFile];     NSError *error;  [fm removeItemAtPath:self.tempFile error:&error];  }     // reset the progress view  if (downloadSize != 0L) {  [progressView addAmountToDownload:-downloadSize];  [progressView addAmountDownloaded:-totalDownloaded];  }}
- (void)connectionDidFinishLoading:(NSURLConnection *)connection {  // close the file  [self.outputHandle closeFile];     // Move the file to the target location  NSFileManager *fm = [NSFileManager defaultManager];  NSError *error;  [fm moveItemAtPath:self.tempFile   toPath:self.targetFile   error:&error];     // Notify any concerned classes that the download is complete  [[NSNotificationCenter defaultCenter]   postNotificationName:kDownloadComplete   object:nil   userInfo:nil];}

Asynchronous Requests and Run Loops