Home > Articles > Programming > General Programming/Other Languages

  • Print
  • + Share This
  • 💬 Discuss
This chapter is from the book

Introducing the Fetched Results Controller

A fetched results controller (NSFetchedResultsController) is a very effective liaison between Core Data and a UITableView. The fetched results controller provides a way to set up a fetch request so that the results are returned in sections and rows, accessible by index paths. In addition, the fetched results controller can listen to changes in Core Data and update the table accordingly using delegate methods.

In the sample app, refer to ICFMovieListViewController for a detailed example of a fetched results controller in action (see Figure 13.9).

Figure 13.9

Figure 13.9 Sample App: Movie list view controller.

Preparing the Fetched Results Controller

When the “master” view controller is set up using Xcode’s Master Detail template, Xcode creates a property for the fetched results controller, and overrides the accessor method (fetchedResultsController) to lazy load or initialize the fetched results controller the first time it is requested. First the method checks to see whether the fetched results controller has already been initialized:

if (__fetchedResultsController != nil)
{
  return __fetchedResultsController;
}

If the fetched results controller is already set up, it is returned. Otherwise, a new fetched results controller is set up, starting with a fetch request:

NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];

The fetch request needs to be associated with an entity from the managed object model, and a managed object context:

NSManagedObjectContext *moc = kAppDelegate.managedObjectContext;

NSEntityDescription *entity =
 [NSEntityDescription entityForName:@"Movie"
       inManagedObjectContext:moc];

[fetchRequest setEntity:entity];

A batch size can be set up to prevent the fetch request from fetching too many records at once:

[fetchRequest setFetchBatchSize:20];

Next, the sort order is established for the fetch request using NSSortDescriptor instances. An important point to note is that the attribute used for sections needs to be the first in the sort order so that the records can be correctly divided into sections. The sort order is determined by the order of the sort descriptors in the array of sort descriptors attached to the fetch request.

NSSortDescriptor *sortDescriptor =
 [[NSSortDescriptor alloc] initWithKey:@"title"
               ascending:YES];

NSSortDescriptor *sharedSortDescriptor =
 [[NSSortDescriptor alloc] initWithKey:@"lent" ascending:NO];

NSArray *sortDescriptors = [NSArray arrayWithObjects:
              sharedSortDescriptor,sortDescriptor,
              nil];

[fetchRequest setSortDescriptors:sortDescriptors];

After the fetch request is ready, the fetched results controller can be initialized. It requires a fetch request, a managed object context, a key path or an attribute name to be used for the table view sections, and a name for a cache (if nil is passed, no caching is done). The fetched results controller can specify a delegate that will respond to any Core Data changes. When this is complete, the fetched results controller is assigned to the view controller’s property:

NSFetchedResultsController *aFetchedResultsController =
 [[NSFetchedResultsController alloc]
 initWithFetchRequest:fetchRequest
 managedObjectContext:moc
  sectionNameKeyPath:@"lent"
       cacheName:nil];

aFetchedResultsController.delegate = self;
self.fetchedResultsController = aFetchedResultsController;

Now that the fetched results controller has been prepared, the fetch can be executed to obtain a result set the table view can display, and the fetched results controller can be returned to the caller:

NSError *error = nil;
if (![self.fetchedResultsController performFetch:&error])
{
  NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
  abort();
}

return __fetchedResultsController;

Integrating Table View and Fetched Results Controller

Integrating the table view and fetched results controller is just a matter of updating the table view’s datasource and delegate methods to use information from the fetched results controller. In ICFMovieListViewController, the fetched results controller tells the table view how many sections it has:

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{
  return [[self.fetchedResultsController sections] count];
}

The fetched results controller tells the table view how many rows are in each section, using the NSFetchedResultsSectionInfo protocol:

- (NSInteger)tableView:(UITableView *)tableView
 numberOfRowsInSection:(NSInteger)section
{
  id <NSFetchedResultsSectionInfo> sectionInfo =
   [[self.fetchedResultsController sections]
   objectAtIndex:section];

  return [sectionInfo numberOfObjects];
}

The fetched results controller provides section titles, which are the values of the attribute specified as the section name. Since the sample app is using a Boolean attribute for the sections, the values that the fetched results controller returns for section titles are not user-friendly titles: 0 and 1. The sample app looks at the titles from the fetched results controller and returns more helpful titles: Shared instead of 1 and Not Shared instead of 0.

- (NSString *)tableView:(UITableView *)tableView
 titleForHeaderInSection:(NSInteger)section
{
  id <NSFetchedResultsSectionInfo> sectionInfo =
   [[self.fetchedResultsController sections]
   objectAtIndex:section];

  if ([[sectionInfo indexTitle] isEqualToString:@"1"])
  {
    return @"Shared";
  }
  else
  {
    return @"Not Shared";
  }
}

To populate the table cells, the sample app dequeues a reusable cell, and then calls the configureView: method, passing the indexPath for the cell:

- (UITableViewCell *)tableView:(UITableView *)tableView
     cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
  UITableViewCell *cell =
   [tableView dequeueReusableCellWithIdentifier:@"Cell"];

  [self configureCell:cell atIndexPath:indexPath];

  return cell;
}

The fetched results controller knows which movie should be displayed at each index path, so the sample app can get the correct movie to display by calling the objectAtIndexPath: method on the fetched results controller. Then, it is simple to update the cell with data from the movie instance.

- (void)configureCell:(UITableViewCell *)cell
     atIndexPath:(NSIndexPath *)indexPath
{
  ICFMovie *movie =
   [self.fetchedResultsController objectAtIndexPath:indexPath];

  cell.textLabel.text = [movie cellTitle];

  cell.detailTextLabel.text = [movie movieDescription];
}

The last table-view integration detail would typically be handling table cell selection in the tableView:didSelectRowAtIndexPath: method. In this case, no integration in that method is needed since selection is handled by storyboard segue. In the prepareForSegue:sender: method, selection of a table cell is handled with an identifier called showDetail:

if ([[segue identifier] isEqualToString:@"showDetail"])
{
NSIndexPath *indexPath =
     [self.tableView indexPathForSelectedRow];

    ICFMovie *movie =
     [[self fetchedResultsController]
       objectAtIndexPath:indexPath];

    ICFMovieDisplayViewController *movieDisplayVC =
     (ICFMovieDisplayViewController *)
      [segue destinationViewController];

    [movieDisplayVC setMovieDetailID:[movie objectID]];
}

This method gets the index path of the selected row from the table view, and then gets the movie instance from the fetched results controller using the index path. The method then sets the movieDetailID of the ICFMovieDisplayViewController instance with the movie instance’s objectID.

Responding to Core Data Changes

For the fetched results controller to respond to Core Data changes and update the table view, methods from the NSFetchedResultsControllerDelegate protocol need to be implemented. First the view controller needs to declare that it will implement the delegate methods:

@interface ICFMovieListViewController : UITableViewController
 <NSFetchedResultsControllerDelegate>

The fetched results controller delegate will be notified when content will be changed, giving the delegate the opportunity to animate the changes in the table view. Calling the beginUpdates method on the table view tells it that all updates until endUpdates is called should be animated simultaneously.

- (void)controllerWillChangeContent:
  (NSFetchedResultsController *)controller
{
  [self.tableView beginUpdates];
}

There are two delegate methods that might be called based on data changes. One method will tell the delegate that changes occurred that affect the table-view sections; the other will tell the delegate that the changes affect objects at specified index paths, so the table view will need to update the associated rows. Because the data changes are expressed by type, the delegate will be notified if the change is an insert, a delete, a move, or an update, so a typical pattern is to build a switch statement to perform the correct action by change type. For sections, the sample app will only make changes that can insert or delete a section (if a section name is changed, that might trigger a case in which a section might move and be updated as well).

- (void)controller:(NSFetchedResultsController *)controller
 didChangeSection:(id <NSFetchedResultsSectionInfo>)sectionInfo
      atIndex:(NSUInteger)sectionIndex
   forChangeType:(NSFetchedResultsChangeType)type
{
  switch(type)
  {
    case NSFetchedResultsChangeInsert:
      ...
      break;

    case NSFetchedResultsChangeDelete:
      ...
      break;
  }
}

Table views have a convenient method to insert new sections, and the delegate method receives all the necessary information to insert new sections:

[self.tableView
  insertSections:[NSIndexSet indexSetWithIndex:sectionIndex]
 withRowAnimation:UITableViewRowAnimationFade];

Removing sections is just as convenient:

[self.tableView
  deleteSections:[NSIndexSet indexSetWithIndex:sectionIndex]
 withRowAnimation:UITableViewRowAnimationFade];

For object changes, the delegate will be informed of the change type, the object that changed, the current index path for the object, and a “new” index path if the object is being inserted or moved. Using switch logic to respond by change type works for this method as well.

- (void)controller:(NSFetchedResultsController *)controller
  didChangeObject:(id)anObject
    atIndexPath:(NSIndexPath *)indexPath
   forChangeType:(NSFetchedResultsChangeType)type
   newIndexPath:(NSIndexPath *)newIndexPath
{
  UITableView *tableView = self.tableView;

  switch(type)
  {
    case NSFetchedResultsChangeInsert:
      ...
      break;

    case NSFetchedResultsChangeDelete:
      ...
      break;

    case NSFetchedResultsChangeUpdate:
      ...
      break;

    case NSFetchedResultsChangeMove:
      ...
      break;
  }
}

Table views have convenience methods to insert rows by index path. Note that the newIndexPath is the correct index path to use when inserting a row for an inserted object.

[tableView
 insertRowsAtIndexPaths:[NSArray arrayWithObject:newIndexPath]
    withRowAnimation:UITableViewRowAnimationFade];

To delete a row, use the indexPath passed to the delegate method.

[tableView
 deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath]
    withRowAnimation:UITableViewRowAnimationFade];

To update a row, call the configureCell:atIndexPath: method for the current indexPath. This is the same configure method called from the table view delegate’s tableView:cellForRowAtIndexPath: method.

[self configureCell:[tableView cellForRowAtIndexPath:indexPath]
    atIndexPath:indexPath];

To move a row, delete the row for the current indexPath and insert a row for the newIndexPath.

[tableView
 deleteRowsAtIndexPaths:[NSArray arrayWithObject:indexPath]
    withRowAnimation:UITableViewRowAnimationFade];

[tableView
 insertRowsAtIndexPaths:[NSArray arrayWithObject:newIndexPath]
    withRowAnimation:UITableViewRowAnimationFade];

The fetched results controller delegate will be notified when the content changes are complete, so the delegate can tell the table view there will be no more animated changes by calling the endUpdates method. After that method is called, the table view will animate the accumulated changes in the user interface.

- (void)controllerDidChangeContent:
  (NSFetchedResultsController *)controller
{
  [self.tableView endUpdates];
}
  • + Share This
  • 🔖 Save To Your Account

Discussions

comments powered by Disqus