Your Homepwner application currently uses archiving to save and reload its data. For a moderately sized object model (say, under 1000 objects), this is fine. As your object model gets larger, however, you will want to be able to do incremental fetches and updates, and Core Data can do this.
The very first step is to add the Core Data framework to your project. Select the Homepwner target and under Build Phases, open the Link Binary With Libraries build phase. Click the button to add the Core Data framework.
In a relational database, we have something called a table. A table represents some type; You can have a table of people, a table of a credit card purchases, or a table of real-estate listings. Each table has a number of columns to hold a piece of information about that thing. A table that represents people might have a column for the person’s name, social security number, height, and age. Every row in the table represents a single person.
This organization translates well to Objective-C. Every table is like an Objective-C class. Every column is one of the class’ instance variables. Every row is one of the instances of that class. Thus, Core Data’s job is to move data to and from these two organizations (Figure 17.2).
Core Data uses different terminology to describe these ideas of table/class, column/instance variable and row/object. A table is called a entity. The instance variables are called attributes. A Core Data model file is the description of every entity and their attributes in your application. Therefore, you will describe a Possession entity in a model file and give it attributes like possessionName, serialNumber and valueInDollars.
From the menu, create a new file. Select Core Data and create a new Data Model. Name it Homepwner.xcdatamodeld.
This will create a Homepwner.xcdatamodeld file and add it to your project. Open this file. The editor area will now show the user interface for manipulating a Core Data model file.
Click the Add Entity button near the bottom of the window. A new Entity will appear in the Entities list. Double-click this entity and change its name to Possession (Figure 17.4).
Now you will add attributes to the Possession entity, remembering that these will be the instance variables of the Possession class. For each attribute, click the + button in the Attributes section and edit the Attribute and Type values for each one:
- possessionName is a String
- serialNumber is a String
- valueInDollars is an Integer 32
- dateCreated is a Date
- imageKey is a String
- thumbnailData is a Binary Data
- thumbnail is an Undefined (It’s a UIImage, but that isn’t one of the possibilities.)
Select thumbnail from the Attributes list and show the data model inspector. Check the box for Transient (Figure 17.5). This means it will not be saved and loaded from the file. You will create it at runtime from the thumbnailData instead.
There is one more attribute to add. In Homepwner, users can order their possessions by moving them around in the table view. Archiving possessions in an array naturally respects this order. However, relational tables don’t order their rows. Instead, when you fetch a set of rows, you specify their order using one of the attributes (“Fetch me all the Employee objects ordered by lastName.”). To maintain the order of possessions, you need to create an attribute to record each possession’s position in the table view. Then when you fetch possessions, you can ask for them to be ordered by this attribute. (You’ll also need to update that attribute when the possessions are reordered.) Create this final attribute: name it orderingValue and make it a Double.
At this point, your model file is sufficient to save and load possessions. However, one of the benefits to using Core Data is that entities can be related to one another. In this exercise, you will add a new entity called AssetType, which describes a category for the possessions. For example, a painting might be of the Art asset type. Of course, AssetType will be an entity in the model file, and each row of that table will be mapped to an Objective-C object at runtime. Every Possession will have a pointer to its AssetType object, and every AssetType will have a list of the Possessions that fall into its category.
Create a new entity called AssetType.
Add an attribute called label of type String to AssetType. This will be the name of the category the AssetType represents.
Now, you need to establish the relationship between AssetType and Possession. There are two kinds of relationships: to-many and to-one. When an entity has a to-one relationship, each instance of that entity will have a pointer to an instance in the entity it has a relationship to. For example, the Possession entity will have a to-one relationship to the AssetType entity. Thus, a Possession instance will have a pointer to its AssetType instance.
The AssetType entity, on the other hand, will have a to-many relationship to Possession since many Possessions can be of the same AssetType type. With these relationships, we can ask an AssetType object for a set of all of the Possessions that fall into its category, and we can ask a Possession which AssetType it falls under.
Let’s add these relationships. Select the AssetType entity and then click the + button in the Relationships section. Name the relationship possessions in the Relationship column. Then, select Possession from the Destination column. In the data model inspector, check the box for To-Many Relationship (Figure 17.8).
Now go back to the Possession entity. Add a relationship named assetType and pick AssetType as its destination. In the Inverse column, select possessions (Figure 17.9).
One final note on terminology: In the language of entity-relationship modeling, the attributes and relationships of an entity are collectively known as its properties.
When an object is fetched with Core Data, its class is, by default, NSManagedObject. NSManagedObject is a subclass of NSObject that knows how to cooperate with the rest of Core Data. Therefore, when you fetch an AssetType or a Possession from Core Data, the object that you get back is an instance of NSManagedObject. This can be confusing, since these two entities have different attributes and therefore the classes that represent these entities should have different instance variables. However, NSManagedObject works a bit like a dictionary in that it holds arbitrary key-value pairs. Thus, an NSManagedObject holds a key-value pair for every property in the entity.
NSManagedObject is little more than a data container. Sometimes, you would like your model objects to do something in addition to holding data. For example, the Possession class knows how to create a thumbnail from an image. When an objects of a particular entity need to perform custom behavior, you must create a subclass of NSManagedObject. Then, in your model file, you must specify that this entity is represented by instances of this subclass, not the standard NSManagedObject.
Select the Possession entity. Show the data model inspector and change the Class field to Possession, as shown in Figure 17.10. Now, when a Possession entity is fetched with Core Data, the type of this object will be Possession. (AssetType instances will still be of type NSManagedObject.)
There is one problem: you already have a Possession class, and it does not inherit from NSManagedObject. Changing the superclass of Possession to NSManagedObject will require considerable changes. Thus, the easiest solution is to copy the behavior methods from your current Possession class, have Core Data generate a new Possession class, and then add your behavior methods back in to the new class files.
In Finder, drag both Possession.h and Possession.m to your desktop. Then, in Xcode, delete these two files from the project navigator.
Then, create a new file. Under Core Data, select the NSManagedObject subclass option and hit Next. On the next pane, select the Homepwner data model. On the following pane, select the Possession entity.
Xcode will generate two new files, Possession.h and Possession.m. In Possession.h, change the type of the thumbnail property to UIImage and add two method declarations that you had previously implemented in the earlier Possession.
#import <Foundation/Foundation.h>
#import <CoreData/CoreData.h>
@interface Possession : NSManagedObject {
@private
}
@property (nonatomic, retain) NSString *serialNumber;
@property (nonatomic, retain) NSNumber *valueInDollars;
@property (nonatomic, retain) UIImage *thumbnail;
@property (nonatomic, retain) NSString *imageKey;
@property (nonatomic, retain) NSDate *dateCreated;
@property (nonatomic, retain) NSString *possessionName;
@property (nonatomic, retain) NSData *thumbnailData;
@property (nonatomic, retain) NSNumber *orderingValue;
@property (nonatomic, retain) NSManagedObject *assetType;
- (void)setThumbnailDataFromImage:(UIImage *)image;
+ (CGSize)thumbnailSize;
@end
Next, in Possession.m, copy the setThumbnailDataFromImage: and thumbnailSize methods from your old Possession.m to the new one:
- (void)setThumbnailDataFromImage:(UIImage *)image
{
CGSize origImageSize = [image size];
CGRect newRect;
newRect.origin = CGPointZero;
newRect.size = [[self class] thumbnailSize];
float ratio = MAX(newRect.size.width/origImageSize.width,
newRect.size.height/origImageSize.height);
// Create a bitmap image context
UIGraphicsBeginImageContext(newRect.size);
// Round the corners
UIBezierPath *path = [UIBezierPath bezierPathWithRoundedRect:newRect
cornerRadius:5.0];
[path addClip];
// Into what rectangle shall I composite the image?
CGRect projectRect;
projectRect.size.width = ratio * origImageSize.width;
projectRect.size.height = ratio * origImageSize.height;
projectRect.origin.x = (newRect.size.width - projectRect.size.width) / 2.0;
projectRect.origin.y = (newRect.size.height - projectRect.size.height) / 2.0;
// Draw the image on it
[image drawInRect:projectRect];
// Get the image from the image context, retain it as our thumbnail
UIImage *small = UIGraphicsGetImageFromCurrentImageContext();
[self setThumbnail:small];
// Get the image as a PNG data
NSData *data = UIImagePNGRepresentation(small);
[self setThumbnailData:data];
// Cleanup image contex resources, we're done
UIGraphicsEndImageContext();
}
+ (CGSize)thumbnailSize
{
return CGSizeMake(40, 40);
}
The thumbnail attribute is not going to be saved – it is a transient attribute. You’ll need to update thumbnail from the thumbnailData when the object first emerges from the filesystem. When Homepwner used keyed archiving, we did this in initWithCoder:. Now that we’re using Core Data, objects are initialized by another Core Data object that handles creating, updating, and deleting NSManagedObjects. (You will meet this object in a moment.) Thus, you do not implement init methods for NSManagedObject subclasses. Instead, if you want to configure an object after it has been created, you override the method awakeFromFetch. Implement this method in Possession.m to set the thumbnail from the thumbnailData (which is saved).
- (void)awakeFromFetch
{
[super awakeFromFetch];
UIImage *tn = [UIImage imageWithData:[self thumbnailData]];
[self setPrimitiveValue:tn forKey:@"thumbnail"];
}
As mentioned earlier, an instance of NSManagedObject works like a dictionary – it can hold a large number of key-value pairs. The method setPrimitiveValue:forKey: works like setObject:forKey: of NSMutableDictionary. One of the amazing and delightful things about Core Data is that instances of NSManagedObject can dynamically create accessor methods as they are called. It will also automatically create methods for primitive access. For example, the following also would have worked:
- (void)awakeFromFetch
{
[super awakeFromFetch];
UIImage *tn = [UIImage imageWithData:[self thumbnailData]];
// At runtime, setPrimitiveThumbnail: will be created when first called
[self setPrimitiveThumbnail:tn];
}
However, we would have received a warning from the compiler because it has no declaration of this method.
Of course, when you first launch an application, there are no saved Possessions or AssetTypes. When the user creates a new Possession instance, it will be added to the database. When objects are added to the database, they are sent the message awakeFromInsert. Here is where you will set the dateCreated instance variable of a Possession. Implement this method in Possession.m.
- (void)awakeFromInsert
{
[super awakeFromInsert];
[self setDateCreated:[NSDate date]];
}
The portal through which you talk to the database is the NSManagedObjectContext. The NSManagedObjectContext uses an NSPersistentStoreCoordinator. You ask the persistent store coordinator to open a SQLite database at a particular filename. The persistent store coordinator uses the model file in the form of an instance of NSManagedObjectModel.
In PossessionStore.h, add instance variables and import Core Data. Also, create a method for getting all the AssetType objects:
#import <CoreData/CoreData.h>
@class Possession;
@interface PossessionStore : NSObject
{
NSMutableArray *allPossessions;
NSMutableArray *allAssetTypes;
NSManagedObjectContext *context;
NSManagedObjectModel *model;
}
+ (PossessionStore *)defaultStore;
- (BOOL)saveChanges;
#pragma mark Possessions
- (NSArray *)allPossessions;
- (Possession *)createPossession;
- (void)removePossession:(Possession *)p;
- (void)movePossessionAtIndex:(int)from toIndex:(int)to;
#pragma mark Asset types
- (NSArray *)allAssetTypes;
@end
This is the first time you’ve seen the #pragma mark construct. Objective-C programmers often use this to group methods. It isn’t used by the compiler at all – rather, Xcode notes it when it creates the pop-up at the top of the editor (Figure 17.12).
When the PossessionStore is initialized, it needs to set up the NSManagedObjectContext and NSPersistentStoreCoordinator. The persistent store coordinator needs to know two things: “What are all of my entities and their attributes and relationships?” and “Where am I saving and loading data from?” Therefore, you will create an instance of NSManagedObjectModel to hold the entity information from Homepwner.xcdatamodeld and initialize the persistent store coordinator with this object. Then, you will create the instance of NSManagedObjectContext and specify that it use this persistent store coordinator to save and load objects. Update init in PossessionStore.m.
- (id)init
{
if (defaultStore) {
return defaultStore;
}
self = [super init];
// Read in Homepwner.xcdatamodeld
model = [[NSManagedObjectModel mergedModelFromBundles:nil] retain];
// NSLog(@"model = %@", model);
NSPersistentStoreCoordinator *psc =
[[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:model];
// Where does the SQLite file go?
NSString *path = pathInDocumentDirectory(@"store.data");
NSURL *storeURL = [NSURL fileURLWithPath:path];
NSError *error = nil;
if (![psc addPersistentStoreWithType:NSSQLiteStoreType
configuration:nil
URL:storeURL
options:nil
error:&error]) {
[NSException raise:@"Open failed"
format:@"Reason: %@", [error localizedDescription]];
}
// Create the managed object context
context = [[NSManagedObjectContext alloc] init];
[context setPersistentStoreCoordinator:psc];
[psc release];
// The managed object context can manage undo, but we don't need it
[context setUndoManager:nil];
return self;
}
Before, PossessionStore would write out the entire NSMutableArray of Possessions when you asked it to save using keyed archiving. Now, you will have it send the message save: to the NSManagedObjectContext. The context will update all of the records in store.data with any changes since the last time it was saved. Change this method in PossessionStore.m.
- (BOOL)saveChanges
{
NSError *err = nil;
BOOL successful = [context save:&err];
if (!successful) {
NSLog(@"Error saving: %@", [err localizedDescription]);
}
return successful;
}
Note that this method is already called when the application is moved to the background.
In this application, we will fetch all of the Possessions in store.data the first time we need to use them. In order to get objects back from the NSManagedObjectContext, you must prepare and execute an NSFetchRequest. After a fetch request is executed, you will get an array of all the objects that match the parameters of that request.
A fetch request needs an entity description that defines which entity you want to get objects from. In order to fetch Possession instances, you specify the Possession entity. You can also set the request’s sort descriptors, which specify the order of the objects in the array. A sort descriptor has a key that maps to an attribute of the entity and a BOOL that indicates if the order should be ascending or descending. You will sort the returned Possessions by their orderingValue in ascending order. Replace the fetchPossessionsIfNecessary method in PossessionStore.m.
- (void)fetchPossessionsIfNecessary
{
if (!allPossessions) {
NSFetchRequest *request = [[[NSFetchRequest alloc] init] autorelease];
NSEntityDescription *e = [[model entitiesByName] objectForKey:@"Possession"];
[request setEntity:e];
NSSortDescriptor *sd = [NSSortDescriptor
sortDescriptorWithKey:@"orderingValue"
ascending:YES];
[request setSortDescriptors:[NSArray arrayWithObject:sd]];
NSError *error;
NSArray *result = [context executeFetchRequest:request error:&error];
if (!result) {
[NSException raise:@"Fetch failed"
format:@"Reason: %@", [error localizedDescription]];
}
allPossessions = [[NSMutableArray alloc] initWithArray:result];
}
}
In this application, you immediately fetched all the instances of the Possession entity. This is a relatively simple case. In an application with a much larger data set, you would carefully fetch just the instances you needed. You would add a predicate (an NSPredicate) to your fetch request, and only the objects that satisfied the predicate would be returned.
A predicate contains a condition which can be true or false. For example, if you only wanted the possessions worth more than $50, you would create a predicate and add it to the fetch request like this:
NSPredicate *p = [NSPredicate predicateWithFormat:@"valueInDollars > 50"]; [request setPredicate:p];
The format string for a predicate can be very long and complex. Apple’s Predicate Programming Guide is a complete discussion of what is possible.
Predicates can also be used to filter the contents of an array. So, even if you had already fetched the allPossessions array, you could still use a predicate:
NSArray *expensiveStuff = [allPossessions filteredArrayUsingPredicate:p];
This handles saving and loading, but what about adding and deleting? When the user wants to create a new Possession, you will not allocate and initialize this new Possession. Instead, you will ask the NSManagedObjectContext to insert a new object from the Possession entity. It will then return an instance of Possession. In PossessionStore.m, edit the createPossession method.
- (Possession *)createPossession
{
// Ensure the array is initialized
[self fetchPossessionsIfNecessary];
double order;
if ([allPossessions count] == 0) {
order = 1.0;
} else {
order = [[[allPossessions lastObject] orderingValue] doubleValue] + 1.0;
}
NSLog(@"Adding after %d items, order = %.2f",[allPossessions count], order);
Possession *p = [NSEntityDescription insertNewObjectForEntityForName:@"Possession"
inManagedObjectContext:context];
[p setOrderingValue:[NSNumber numberWithDouble:order]];
[allPossessions addObject:p];
return p;
}
When a user deletes a Possession, you must inform the context so that it is removed from the database when saved. Add the following code to PossessionStore.m’s removePossession: method.
- (void)removePossession:(Possession *)p
{
NSString *key = [p imageKey];
[[ImageStore defaultImageStore] deleteImageForKey:key];
[context deleteObject:p];
[allPossessions removeObjectIdenticalTo:p];
}
The last bit of functionality you need to replace for Possession is the ability to re-order Possessions in the PossessionStore. Because Core Data will not handle ordering automatically, we must update a Possession’s orderingValue every time it is moved in the table view.
This would get rather complicated if the orderingValue was an integer: every time a Possession was placed in a new index, we would have to change the orderingValue’s of other Possessions. Instead, orderingValue is a double. We can then take the orderingValues of the Possession that will be before and after the moving possession, add them together, and divide by two. Thus, the new orderingValue will fall directly in between the values of the Possessions that surround it. Modify movePossessionAtIndex:toIndex: in PossessionStore.m.
- (void)movePossessionAtIndex:(int)from
toIndex:(int)to
{
if (from == to) {
return;
}
// Get pointer to object being moved
Possession *p = [allPossessions objectAtIndex:from];
// Retain it so it doesn't get dealloced while out of array
[p retain];
// Remove p from our array
[allPossessions removeObjectAtIndex:from];
// Re-insert p into array at new location
[allPossessions insertObject:p atIndex:to];
// Computing a new orderValue for the object that was moved
double lowerBound = 0.0;
// Is there an object before it in the array?
if (to > 0) {
lowerBound = [[[allPossessions objectAtIndex:to - 1]
orderingValue] doubleValue];
} else {
lowerBound = [[[allPossessions objectAtIndex:1]
orderingValue] doubleValue] - 2.0;
}
double upperBound = 0.0;
// Is there an object after it in the array?
if (to < [allPossessions count] - 1) {
upperBound = [[[allPossessions objectAtIndex:to + 1]
orderingValue] doubleValue];
} else {
upperBound = [[[allPossessions objectAtIndex:to - 1]
orderingValue] doubleValue] + 2.0;
}
// The order value will be the midpoint between the lower and upper bounds
NSNumber *n = [NSNumber numberWithDouble:(lowerBound + upperBound)/2.0];
NSLog(@"moving to order %@", n);
[p setOrderingValue:n];
// Release p (retain count = 1, only owner is now array)
[p release];
}
One last detail. When we moved Possession to a subclass of NSManagedObject, the valueInDollars property became an instance of NSNumber instead of an int. There are three places we still use this instance variable. Update the code in the viewWillAppear: method of ItemDetailViewController.m.
- (void)viewWillAppear:(BOOL)animated
{
[super viewWillAppear:animated];
[nameField setText:[possession possessionName]];
[serialNumberField setText:[possession serialNumber]];
if([possession valueInDollars]) {
// Notice that the format string changed
[valueField setText:[NSString stringWithFormat:@"%@",
[possession valueInDollars]]];
} else {
[valueField setText:@"0"];
}
NSDateFormatter *dateFormatter = [[[NSDateFormatter alloc] init] autorelease];
In the same file, update viewWillDisappear:.
- (void)viewWillDisappear:(BOOL)animated
{
[super viewWillDisappear:animated];
// End any incomplete editing
[[self view] endEditing:YES];
// "Save" changes to possession
[possession setPossessionName:[nameField text]];
[possession setSerialNumber:[serialNumberField text]];
NSNumber *valueNum = [NSNumber numberWithInt:[[valueField text] intValue]];
[possession setValueInDollars:valueNum];
}
And the third and final spot, in HomepwnerItemCell.m:
- (void)setPossession:(Possession *)possession
{
// The format string changes again
[valueLabel setText:[NSString stringWithFormat:@"$%@",
[possession valueInDollars]]];
[nameLabel setText:[possession possessionName]];
[imageView setImage:[possession thumbnail]];
}
Finally, you can build and run your application. Of course, the behavior is the same as it always was, but it is now using Core Data. Now, you need to take care of the new asset type functionality.
In the model file, you described a new entity, AssetType, that every possession will have a to-one relationship to. You need a way for the user to set the AssetType of Possessions and create new AssetTypes. Also, the PossessionStore will need a way to fetch the AssetTypes. (Creating new AssetTypes is left as a challenge.)
In PossessionStore.h, declare a new method.
- (NSArray *)allAssetTypes;
In PossessionStore.m, define this method. If this is the first time the application is being run – and therefore there are no AssetTypes in the store – create three default types.
- (NSArray *)allAssetTypes
{
if (!allAssetTypes) {
NSFetchRequest *request = [[[NSFetchRequest alloc] init] autorelease];
NSEntityDescription *e = [[model entitiesByName] objectForKey:@"AssetType"];
[request setEntity:e];
NSError *error;
NSArray *result = [context executeFetchRequest:request error:&error];
if (!result) {
[NSException raise:@"Fetch failed"
format:@"Reason: %@", [error localizedDescription]];
}
allAssetTypes = [result mutableCopy];
}
// Is this the first time the program is being run?
if ([allAssetTypes count] == 0) {
NSManagedObject *type;
type = [NSEntityDescription insertNewObjectForEntityForName:@"AssetType"
inManagedObjectContext:context];
[type setValue:@"Furniture" forKey:@"label"];
[allAssetTypes addObject:type];
type = [NSEntityDescription insertNewObjectForEntityForName:@"AssetType"
inManagedObjectContext:context];
[type setValue:@"Jewelry" forKey:@"label"];
[allAssetTypes addObject:type];
type = [NSEntityDescription insertNewObjectForEntityForName:@"AssetType"
inManagedObjectContext:context];
[type setValue:@"Electronics" forKey:@"label"];
[allAssetTypes addObject:type];
}
return allAssetTypes;
}
Now, you need change the user interface so that the user can see the AssetType of the Possession in the ItemDetailViewController and change it.
Create a new Objective-C class template file and choose NSObject as the superclass. Name this class AssetTypePicker.
In AssetTypePicker.h, change the superclass to UITableViewController and give it a Possession property.
#import <UIKit/UIKit.h>
@class Possession;
@interface AssetTypePicker : UITableViewController
{
Possession *possession;
}
@property (nonatomic, retain) Possession *possession;
@end
This table view controller will show a list of the available AssetTypes. Tapping a button on the ItemDetailViewController’s view will display it (in a popover on the iPad and in a navigation controller on the iPhone). Implement the data source methods and import the appropriate header files in AssetTypePicker.m.
#import "AssetTypePicker.h"
#import "PossessionStore.h"
#import "Possession.h"
@implementation AssetTypePicker
@synthesize possession;
- (id)init
{
return [super initWithStyle:UITableViewStyleGrouped];
}
- (id)initWithStyle:(UITableViewStyle)style
{
return [self init];
}
- (void)dealloc
{
[possession release];
[super dealloc];
}
- (NSInteger)tableView:(UITableView *)tableView
numberOfRowsInSection:(NSInteger)section
{
return [[[PossessionStore defaultStore] allAssetTypes] count];
}
- (UITableViewCell *)tableView:(UITableView *)tableView
cellForRowAtIndexPath:(NSIndexPath *)ip
{
UITableViewCell *cell =
[tableView dequeueReusableCellWithIdentifier:@"UITableViewCell"];
if (cell == nil) {
cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault
reuseIdentifier:@"UITableViewCell"]
autorelease];
}
NSArray *allAssets = [[PossessionStore defaultStore] allAssetTypes];
NSManagedObject *assetType = [allAssets objectAtIndex:[ip row]];
// Use key-value coding to get the asset type's label
NSString *assetLabel = [assetType valueForKey:@"label"];
[[cell textLabel] setText:assetLabel];
// Checkmark the one that is currently selected
if (assetType == [possession assetType]) {
[cell setAccessoryType:UITableViewCellAccessoryCheckmark];
} else {
[cell setAccessoryType:UITableViewCellAccessoryNone];
}
return cell;
}
- (void)tableView:(UITableView *)tableView
didSelectRowAtIndexPath:(NSIndexPath *)ip
{
UITableViewCell *cell = [tableView cellForRowAtIndexPath:ip];
[cell setAccessoryType:UITableViewCellAccessoryCheckmark];
NSArray *allAssets = [[PossessionStore defaultStore] allAssetTypes];
NSManagedObject *assetType = [allAssets objectAtIndex:[ip row]];
[possession setAssetType:assetType];
[[self navigationController] popViewControllerAnimated:YES];
}
@end
In ItemDetailViewController.xib, add a new UIButton to the view. Create and connect outlets as shown in Figure 17.14.
At the top of ItemDetailViewController.m, import the header for this new table view controller.
#import "ItemDetailViewController.h" #import "AssetTypePicker.h"
Implement showAssetTypePicker: in ItemDetailViewController.m. (If you generated the action method by Control-dragging from the XIB to the source file, the method will already be entered with an empty body.)
- (IBAction)showAssetTypePicker:(id)sender
{
[[self view] endEditing:YES];
AssetTypePicker *assetTypePicker = [[[AssetTypePicker alloc] init] autorelease];
[assetTypePicker setPossession:possession];
[[self navigationController] pushViewController:assetTypePicker
animated:YES];
}
And finally, update the title of the button to show the asset type of a Possession. Add the following code to viewWillAppear: in ItemDetailViewController.m.
if (imageKey) {
// Get image for image key from image cache
UIImage *imageToDisplay = [[ImageStore defaultImageStore]
imageForKey:imageKey];
// Use that imge to put on the screen in imageView
[imageView setImage:imageToDisplay];
} else {
// clear the imageView
[imageView setImage:nil];
}
NSString *typeLabel = [[possession assetType] valueForKey:@"label"];
if(!typeLabel)
typeLabel = @"None";
[assetTypeButton setTitle:[NSString stringWithFormat:@"Type: %@", typeLabel]
forState:UIControlStateNormal];
}
Build and run the application. Select a Possession and set its asset type.