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