The first pipes you want to lay involve adding controls to the view. Here's what you need to do:

This is the general pattern I use as I build my interface — add stuff, and then simulate it to see how it really looks.

Now that you have the view set up, you need to set up the controller so that you can

To refresh your memory, the view controller can refer to objects created from the nib file by using a special kind of instance variable referred to as an outlet. If I want (for example) to be able to access the Text Field object in my RoadTrip application, I take two steps:

IBOutlet is a keyword that tags an instance-variable declaration so the Interface Builder application knows that a particular instance variable is an outlet — and can then enable the connection to it with Xcode. The fact that a connection between an object and its outlets exists is actually stored in a nib file. When the nib file is loaded, each connection is reconstituted and reestablished — thus enabling you to send messages to the object.

In my code, it turns out I need to create five outlets — one to point to each of the text fields I just set up in Interface Builder.

Then, when my application is initialized, the Text Field outlet is automatically initialized with a pointer to the text field. I can then use that outlet from within my code to get the text the user entered in the text field.

Similarly, Buttons in the nib file can be connected to methods in the view controller by using IBAction as a return type of the method you otherwise declare in the usual way.

IBAction is one of those cool little techniques, like IBOutlet, that does nothing in the code but provide a way to inform Interface Builder (hence, the IB in both of them) that this method can be used as an action for Target-Action connections. All IBAction does is act as a tag for Interface Builder — identifying this method (action) as one you can connect to an object (namely, the Button) in a nib file. In this respect, this whole IBAction trick is similar to the IBOutlet. In that case, however, you were tagging instance variables, in this case, methods. Same difference.

I need to declare two methods — one to execute when the user taps the Get from Contacts button, and the other for when the user taps the Save to Contacts button.

To do that, add the bolded code in Listing 1-1 to AddHotelController.h.

@class Trip;
@class Hotel;

@interface AddHotelController : UIViewController
                                   <UITextFieldDelegate> {
  Trip                 *trip;
  Hotel                *hotel;
  IBOutlet UITextField *street;
  IBOutlet UITextField *state;
  IBOutlet UITextField *zip;
  IBOutlet UITextField *name;
  IBOutlet UITextField *city;
}
- (id) initWithHotel:(Hotel*) theHotel
                                    trip:(Trip*) theTrip;
- (IBAction) getFromContacts:(id) sender;
- (IBAction) saveToContacts:(id) sender;

@end

You start by making the AddHotelController a UITextFieldDelegate — it will be handing the entry of text into the text fields. As you can see, I have had you add seven instance variables. One of them holds a reference to Trip, and the second will hold a reference to a new Hotel object when you do finally create one. The other five are the outlets I explained earlier. The outlets will automatically be initialized with a pointer to the text fields (street, state, zip, name, and city), when the application is launched and will enable you to access the text the user has entered in those fields.

I've also had you declare two new methods (and the usual initialization method), getFromContacts: and saveToContacts:, each with the keyword IBAction as the return type. IBAction is actually defined as a void, so if you think about it, all you've done is declare a new method with a return type of void.

- (IBAction)getFromContacts:(id)sender;

is the same as

- (void) getFromContacts:(id)sender;

This simply means that you've declared a method that doesn't return anything when it's sent a message.

The actual name you give the method can be anything you want, but it must have a return type of IBAction. Usually the action method takes one argument — typically defined as id, a pointer to the instance variables of an object — which is given the name sender. The control that triggers your action will use the sender argument to pass a reference to itself. So, for example, if your action method was invoked as the result of a button tap, the argument sender would contain a reference to the specific button that was tapped.

But even though all these connects will happen automatically, it won't automatically happen automatically. You need to do some work back in Interface Builder first. So put aside Xcode and return to Interface Builder.

When it comes time to dismiss a modal view controller, the preferred method is for the view controller that presented the modal view controller to do the dismissing. And the preferred way to do that is to use delegation.

That brings me to the commented-out line of code back in Listing 1-3:

//addHotelController.delegate = self;

I have this commented out so that you can compile and run the application to check for compiler errors and see how it works. Because I don't have the delegate instance variable defined, it won't compile with that line of code in there, and when I get to explaining how the view controller is dismissed a bit later in this section, I have you uncomment out that line.

For now, you can compile and run the application. Just be sure to delete any previous copies of RoadTrip on your iPhone or simulator.

You'll find that if you tap the Add button in the Hotel list, your view should flip around, showing your new data entry screen.

You can even enter data in the various text fields, but there's no way to dismiss the keyboard — tapping Return doesn't help. There's also another problem — well, actually more than one, but the one you'll notice is that there's no way to get back from this new view. (As I said, you haven't done that yet.)

You also still have to do some things to HotelController to make everything work, and that has to do with how you handled adding the Hotel object previously. So, before you do any more work on the addHotelController, I want you to look at what happens when it's created and pushed on to the stack.

In Chapter 5 of Book VI, you added some code to viewWillDisappear:. You did this because, when the view unloads, undo and redo are no longer possible; you needed to save the current Managed Object Context and resign as first responder. Listing 1-4 shows the code you added.

- (void)viewWillDisappear:(BOOL)animated {

  [super viewWillDisappear:animated];
  [self cleanUpUndoManager];
  // Save the context.
  if (trip.managedObjectContext.hasChanges) {
    NSError *error = nil;
    if (![trip.managedObjectContext save:&error]) {
/*Replace this implementation with code to handle the
  error appropriately. */
      NSLog(@"Unresolved error %@, %@", error,
                                        [error userInfo]);
      abort();
    }
  }
  [trip loadHotels];
  [trip.mapController refreshAnnotations];

  [self resignFirstResponder];
}

This worked fine when the HotelController was the "last stop" in the chain. That is, after you added the hotel, the only place to go was back to the previous view controller, and if you were doing that, it meant you were done with adding a hotel, and in viewWillDisapper: you could do what you needed to based on the last user action.

When you added the AddHotelController, all this changed. The viewWillDisappear: message is now also sent when you're moving from the HotelController to the AddHotelController, and at that point you certainly aren't ready to do much of anything.

Fortunately, enhancing your code to handle this situation is easy.

All you have to do is save the new Hotel and refresh the annotations after the user has returned from the AddHotelController and entered the necessary data. To do that, you'll simply add state information to the HotelController — it needs to know whether it's still in the middle of adding a hotel when the view disappears, or not. If it's in the middle of adding it, don't do anything. If it's not, just do what you were doing before. Start with adding the state information it needs — a Boolean amEditing — to HotelController.h, as shown in bold in Listing 1-5.

@class Trip;
@class Hotel;
#import "AddHotelController.h"

@interface HotelController : UITableViewController
   <NSFetchedResultsControllerDelegate,
   AddHotelControllerDelegate>{
  NSFetchedResultsController *fetchedResultsController;
 Trip                       *trip;
  Hotel                      *hotel;
  NSUndoManager              *undoManager;
  BOOL             amEditing;
}
@property (nonatomic, retain) NSFetchedResultsController
   *fetchedResultsController;
@property (nonatomic, retain) NSUndoManager *undoManager;
- (void)setUpUndoManager;
- (void)cleanUpUndoManager;

@end

In viewWillDisappear:, check the state by adding the code in bold in Listing 1-6 to viewWillDisappear: in HotelController.m.

- (void)viewWillDisappear:(BOOL)animated {
  [super viewWillDisappear:animated];
  if (!amEditing) {
  [self cleanUpUndoManager];
  // Save the context.
  if (trip.managedObjectContext.hasChanges) {
    NSError *error = nil;
    if (![trip.managedObjectContext save:&error]) {
/* Replace this implementation with code to handle the
   error appropriately. */
    NSLog(@"Unresolved error %@, %@", error,
                                        [error userInfo]);
    abort();
    }
 }
 [trip loadHotels];
 [trip.mapController refreshAnnotations];
[self resignFirstResponder];
 }
}

Because you can never be too careful, add the code in bold in Listing 1-7 to initWithTrip: in HotelController.m to initialize the amEditing state.

- (id) initWithTrip: (Trip*) aTrip{
  if (self =
  [super initWithNibName:@"HotelController" bundle:nil]) {
    trip = aTrip;
    [trip retain];
    amEditing = NO;
  }
  return self;
 }

Next, set the state to amEditing in insertNewObject in HotelController.m by adding the bolded code in Listing 1-8. That way, when the AddHotelController is presented, you'll do nothing in viewDidDisappear:.

- (void)insertNewObject {

   NSEntityDescription *entity = [[fetchedResultsController
   fetchRequest] entity];
  hotel = [NSEntityDescription insertNewObjectForEntit
   yForName:[entity name] inManagedObjectContext:trip.
   managedObjectContext]; //$$
  [self setUpUndoManager];
  [hotel setValue:@"Hotel California" forKey:@"name"];
  [hotel setValue:@"1 Dr. Carlton B. Goodlett Place"
   forKey:@"street"];
  [hotel setValue:@"San Francisco" forKey:@"city"];
  [hotel setValue:@"California" forKey:@"state"];
  [hotel setValue:@"94102" forKey:@"zip"];
  amEditing = YES;

  AddHotelController *addHotelController =
   [[AddHotelController alloc] initWithHotel:hotel
   trip:trip];
 UINavigationController *navigationController =
  [[UINavigationController alloc] initWithRootViewController
  :addHotelController];
 navigationController.modalTransitionStyle =
  UIModalTransitionStyleFlipHorizontal;

//addHotelController.delegate = self;
  [self presentModalViewController:navigationController
   animated:YES];
  [navigationController release];
  [addHotelController release];

  Annotation *annotation = [NSEntityDescription ins
   ertNewObjectForEntityForName:@"Annotation"
   inManagedObjectContext:trip.managedObjectContext]; //$$
  [annotation setTitle:@"Annotation"];
  [annotation setHotel:hotel];
  [hotel setAnnotation:annotation];
  Geocoder * geocoder = [[Geocoder alloc] init];
  NSString* geocodeString = [[NSString alloc ]
   initWithFormat: @" %@ %@ %@ %@", hotel.street, hotel.city,
   hotel.state, hotel.zip];
  NSLog (@" finding = %@", geocodeString);
  CLLocationCoordinate2D theCoordinate = [geocoder
   geocodeLocation:geocodeString];
  hotel.annotation.latitude = [NSNumber
   numberWithDouble:theCoordinate.latitude];
  hotel.annotation.longitude = [NSNumber
   numberWithDouble:theCoordinate.longitude];
  hotel.annotation.title = hotel.name;
}

You'll set amEditing back to NO when you return for the entering data in the AddHotelController, but you're not there yet.

Continue on building the AddHotelController.

To dismiss the keyboard, you need to add another method to the AddHotelController — textFieldShouldReturn:. With that method, you have to send a message to the text field to resignFirstResponder. When the text field receives that message, it lowers the keyboard. (I cover lowering keyboards, as well as how to scroll the view so that a text field isn't covered, in exquisite detail in my iPhone Application Development For Dummies; if you're dying to find out more about lowering keyboards and keeping fields uncovered, you should look at that book.)

Enter the code in Listing 1-9 to AddHotelController.

- (BOOL)textFieldShouldReturn:(UITextField *)
                                             theTextField {
   [theTextField resignFirstResponder];
   return YES;
}

Now, you'll discover that, when you tap Return on the keyboard, the keyboard kindly lowers itself.

You'll also be aware of a couple of features that come with using a text field. If, after the user enters text in a text field, he or she just happens to shake the iPhone, the Undo dialog will present itself, as shown in Figure 1-13. To do this on the Simulator (which is what you see in the figure), simply choose Hardware

You'll also notice that pressing in a text field brings up the Select and Paste menu, as shown in Figure 1-14.

Figure 1-13. Undo typing.

Figure 1-14. Select and paste.

Now you need to add two buttons: one to save any changes, and one to enable you to cancel any changes you've made.

To add the buttons, you need to decide how to deal with a save or a cancel. As I indicated earlier, the preferred method is to have the controller that presented the view controller modally become a delegate of the modal view controller and implement a method that will dismiss it (and do whatever else needs to be done) when the modal view controller is done doing its thing (that is, save or cancel).

Before you do that, though, I'd like you to add the buttons. You'll do that in the viewDidLoad method of the AddHotelController.

Add the viewDidLoad method to the AddHotelController by adding the code in Listing 1-10 to AddHotelController.h.

- (void)viewDidLoad {

  [super viewDidLoad];
  self.navigationItem.title = @"Hotel Information";

  UIBarButtonItem *cancelButtonItem =
        [[UIBarButtonItem alloc] initWithTitle:@"Cancel"
        style:UIBarButtonItemStyleBordered target:self
        action:@selector(cancel:)];
  self.navigationItem.leftBarButtonItem =
                                         cancelButtonItem;
  [cancelButtonItem release];

  UIBarButtonItem *saveButtonItem =
         [[UIBarButtonItem alloc] initWithTitle:@"Save"
         style:UIBarButtonItemStyleDone target:self
         action:@selector(save:)];
  self.navigationItem.rightBarButtonItem = saveButtonItem;
  [saveButtonItem release];
}

When you created the buttons, you specified the messages that should be sent (cancel: and save:) when the user tapped a button, and to what object they should be sent (self).

When you specified the button style as UIBarButtonItemStyleDone, that resulted in the familiar blue Save button being displayed. If you compile and run RoadTrip, you'll see that trusty Save button, but don't tap either the Save or Cancel button just yet because you haven't implemented either of their action methods. In fact, you'll do that next.

Add the code in Listing 1-11 to AddHotelController.m to implement the cancel: method and the code in Listing 1-12 to the very same AddHotelController.m to implement the save: method.

- (IBAction)cancel:(id)sender {

  [delegate addHotelController:self didFinishWithSave:NO];
}

When the user taps the Cancel button, the cancel: message is sent to the AddHotelController. It then sends the addHotelController;didFinishWithSave: message to its delegate (the HotelController). I'll show you how that is implemented after I explain the save: method.

- (IBAction)save:(id)sender {

  hotel.street = street.text ;
  hotel.state = state.text;
  hotel.zip = zip.text;
  hotel.name = name.text;
  hotel.city = city.text;

  [delegate addHotelController:self
                                   didFinishWithSave:YES];
}

As you might expect, the save: message updates the Hotel object you created in the HotelController earlier and then also sends the addHotelController;didFinishWithSave: message. The difference, as you will notice, is that, in the case of cancel, the argument is NO, and in the case of save, the argument is YES.

Here's the deal: When it comes time to dismiss a modal view controller, the preferred method is for the view controller that presented the modal view controller to do the dismissing. And the preferred way to do that is delegation.

To implement that, the view controller being presented modally must define a protocol for its delegate to implement. Stored away in this newly defined protocol are the messages(s) that the modal view controller will send in response to specific actions, such as taps in the Save or Cancel buttons. The delegate needs to implement the methods and do what it needs to do to handle either a save or a cancel, which would include — in this example — dismissing the modal view controller.

Listing 1-13 shows the implementation of the addHotelController:did FinishWithSave: method. Add it to HotelController.m.

- (void)addHotelController:
          (AddHotelController *)controller
                            didFinishWithSave:(BOOL)save {
  amEditing = NO;
  if (save) {
    [undoManager setActionName:
               [NSString stringWithString:@"Edit Hotel"]];

    Annotation *annotation = [NSEntityDescription
         insertNewObjectForEntityForName:@"Annotation"

inManagedObjectContext:trip.managedObjectContext];

      [annotation setTitle:@"Annotation"];
      [annotation setHotel:hotel];

      [hotel setAnnotation:annotation];
      Geocoder * geocoder = [[Geocoder alloc] init];
      NSString* geocodeString = [[NSString alloc ]
     initWithFormat: @" %@ %@ %@ %@", hotel.street, hotel.city,
     hotel.state, hotel.zip];
      CLLocationCoordinate2D theCoordinate = [geocoder
     geocodeLocation:geocodeString];
      hotel.annotation.latitude = [NSNumber numberWithDouble:
     theCoordinate.latitude];
      hotel.annotation.longitude =   [NSNumber numberWithDouble:
     theCoordinate.longitude];
      hotel.annotation.title = hotel.name;

    }
    else {
      [trip.managedObjectContext deleteObject:hotel];
      hotel = nil;
      [undoManager setActionName:
               [NSString stringWithString:@"Cancel Hotel"]];
  }
    [self dismissModalViewControllerAnimated:YES];
  }

[undoManager setActionName:
               [NSString stringWithString:@"Edit Hotel"]];

The rest of the code should look familiar — really, it should. Basically, you have moved all of the code that had previously followed the creating of the AddHotelController in insertNewObejct into this new method.

Listing 1-14 shows you the code that you need to now delete (that strike-through stuff) or copy (that bold stuff) from insertNewObject in HotelController.m.

For Cancel, you delete the object you had created, set the hotel instance variable to nil, and set the Undo Manager action name.

Finally, you dismiss the modal view controller, as follows:

[self dismissModalViewControllerAnimated:YES];

- (void)insertNewObject {

   NSEntityDescription *entity = [[fetchedResultsController
   fetchRequest] entity];
  hotel = [NSEntityDescription insertNewObjectForEntit
   yForName:[entity name] inManagedObjectContext:trip.
   managedObjectContext]; //$$
  [self setUpUndoManager];
  [hotel setValue:@"Hotel California" forKey:@"name"];
  [hotel setValue:@"1 Dr. Carlton B. Goodlett Place"
   forKey:@"street"];
  [hotel setValue:@"San Francisco" forKey:@"city"];
  [hotel setValue:@"California" forKey:@"state"];
  [hotel setValue:@"94102" forKey:@"zip"];
  amEditing = YES;

  AddHotelController *addHotelController =
   [[AddHotelController alloc] initWithHotel:hotel
   trip:trip];
  UINavigationController *navigationController =
   [[UINavigationController alloc] initWithRootViewController
   :addHotelController];
  navigationController.modalTransitionStyle =
   UIModalTransitionStyleFlipHorizontal;
  addHotelController.delegate = self;
  [self presentModalViewController:navigationController
   animated:YES];
  [navigationController release];
  [addHotelController release];

  //Annotation *annotation = [NSEntityDescription
   insertNewObjectForEntityForName:@"Annotation"
   inManagedObjectContext:trip.managedObjectContext]; //$$
  //[annotation setTitle:@"Annotation"];
  //[annotation setHotel:hotel];
 // [hotel setAnnotation:annotation];
  // Geocoder * geocoder = [[Geocoder alloc] init];
  // NSString* geocodeString = [[NSString alloc ]
   initWithFormat: @" %@ %@ %@ %@", hotel.street, hotel.
   city, hotel.state, hotel.zip];
 // NSLog (@" finding = %@", geocodeString);
 // CLLocationCoordinate2D theCoordinate = [geocoder
   geocodeLocation:geocodeString];
 // hotel.annotation.latitude = [NSNumber
   numberWithDouble:theCoordinate.latitude];
 // hotel.annotation.longitude = [NSNumber
   numberWithDouble:theCoordinate.longitude];
 /// hotel.annotation.title = hotel.name;
}

You can now also uncomment out the delegate assignment, because you'll implement all of that next:

addHotelController.delegate = self;

The final step is to add all the code necessary to implement delegation

You'll start by adding the code in bold in Listing 1-15 in order to add the protocol (you'll name it AddHotelControllerDelegate) and other required declarations to AddHotelController.h.

#import <UIKit/UIKit.h>
@class Trip;
@class Hotel;
@protocol AddHotelControllerDelegate;

@interface AddHotelController : UIViewController
   <UITextFieldDelegate> {

  id <AddHotelControllerDelegate> delegate;
  Trip                 *trip;
  Hotel                *hotel;
  IBOutlet UITextField *street;
  IBOutlet UITextField *state;
  IBOutlet UITextField *zip;
  IBOutlet UITextField *name;
  IBOutlet UITextField *city;

}
- (id) initWithHotel:(Hotel*) theHotel trip:(Trip*) theTrip;
- (IBAction) getFromContacts: (id) sender;
- (IBAction) saveToContacts: (id) sender;
@property (nonatomic, assign)
                        id <AddHotelControllerDelegate> delegate;
@end

@protocol AddHotelControllerDelegate
- (void)addHotelController:(AddHotelController *)controller
   didFinishWithSave:(BOOL)save;
@end

Both the delegate instance variable and its corresponding property may look a bit odd to you.

id <AddHotelControllerDelegate> delegate;
@property (nonatomic, assign)
                 id <AddHotelControllerDelegate> delegate;

id <AddHotelControllerDelegate> tells the compiler to do type checking for any class assigned to this instance variable or property. The idea here is for the compiler to check to make sure that the class has adopted the AddHotelControllerDelegate protocol. This is one of the advantages of using formal protocols.

You also need to add the following @synthesize statement to AddHotelController.m.

@synthesize delegate;

Then follow up by making the changes in bold in Listing 1-16 to HotelController.h to have it adopt the protocol.

@class Trip;
@class Hotel;
#import "AddHotelController.h"

@interface HotelController : UITableViewController
   <NSFetchedResultsControllerDelegate,
                               AddHotelControllerDelegate> {

  NSFetchedResultsController  *fetchedResultsController;
  Trip                        *trip;
  Hotel                       *hotel;
  NSUndoManager               *undoManager;
}
@property (nonatomic, retain)
    NSFetchedResultsController *fetchedResultsController;
@property (nonatomic, retain) NSUndoManager *undoManager;
- (void)setUpUndoManager;
- (void)cleanUpUndoManager;

@end

You might have noticed that, when I created the hotel object in insert-NewObject, I added some default data:

[hotel setValue:@"Hotel California" forKey:@"name"];
[hotel setValue:@"1 Dr. Carlton B. Goodlett Place"
                                  forKey:@"street"];
[hotel setValue:@"San Francisco" forKey:@"city"];
[hotel setValue:@"California" forKey:@"state"];
[hotel setValue:@"94102" forKey:@"zip"];

But when you displayed the AddHotelController view, there was no data to be seen. That's because you never copied it from the instance variables in the hotel object to the text fields in the view.

Go ahead and do that now by adding the code in bold in Listing 1-17 to viewDidLoad in AddHotelController.m.

- (void)viewDidLoad {
    [super viewDidLoad];
  self.navigationItem.title = @"Hotel Information";

  UIBarButtonItem *cancelButtonItem = [[UIBarButtonItem
   alloc] initWithTitle:@"Cancel" style:UIBarButtonItemStyleB
   ordered target:self action:@selector(cancel:)];
  self.navigationItem.leftBarButtonItem = cancelButtonItem;
  [cancelButtonItem release];

  UIBarButtonItem *saveButtonItem = [[UIBarButtonItem alloc]
   initWithTitle:@"Save" style:UIBarButtonItemStyleDone
   target:self action:@selector(save:)];
  self.navigationItem.rightBarButtonItem = saveButtonItem;
  [saveButtonItem release];
  street.text = hotel.street;
  state.text = hotel.state;
  zip.text = hotel.zip;
  name.text = hotel.name;
  city.text = hotel.city;

If at this point you're thinking to yourself "I understand why you may want to have a view populated with default data under some circumstances, but this doesn't seem to be one of those times," I would have to agree with you.

The reason I'm doing it is to show you how the Undo Manager keeps track of things. I'll leave it to you, however, to implement undo in a way that is more appropriate to your own application.

As you saw in Figure 1-13 earlier, Undo works automatically when you enter some data in a text field. Now you can look what happens when you enter the data, save it, and return to the HotelController.

In Figure 1-15, I shook the iPhone and the Undo Edit Hotel dialog is displayed — that's because that is precisely what you set the text to say earlier in addHotelController:didFinishWithSave: back in Listing 1-13.

Then, if I tap Undo Edit Hotel, the display reverts back to the default — Hotel California. If I shake the device again, I get the Undo Add Hotel message, as you see in Figure 1-16.

Figure 1-15. Undo Edit Hotel.

Figure 1-16. Undo Add Hotel.

- (void)viewDidLoad {

[super viewDidLoad];

self.navigationItem.title = @"Hotel Information";

UIBarButtonItem *cancelButtonItem =
      [[UIBarButtonItem alloc] initWithTitle:@"Cancel"
       style:UIBarButtonItemStyleBordered target:self
       action:@selector(cancel:)];
self.navigationItem.leftBarButtonItem =
                                     cancelButtonItem;
[cancelButtonItem release];

UIBarButtonItem *saveButtonItem =
        [[UIBarButtonItem alloc] initWithTitle:@"Save"
         style:UIBarButtonItemStyleDone target:self
                               action:@selector(save:)];
self.navigationItem.rightBarButtonItem = saveButtonItem;
[saveButtonItem release];
street.text = hotel.street;
state.text = hotel.state;
zip.text = hotel.zip;
name.text = hotel.name;
city.text = hotel.city;
name.autocorrectionType = UITextAutocorrectionTypeNo;
street.autocorrectionType = UITextAutocorrectionTypeNo;
city.autocorrectionType = UITextAutocorrectionTypeNo;
state.autocorrectionType = UITextAutocorrectionTypeNo;
zip.autocorrectionType = UITextAutocorrectionTypeNo;}

If you compile and run this code at this point, it will work, but you still get two warnings, due to the fact that you haven't implemented either of the methods you declared as IBActions to support the contacts buttons.

You'll do that next.

Adding a new contact to the Address Book is similar to accessing one.

You'd start by making the AddHotelController a ABNewPersonViewControllerDelegate. You'll need to add the following to AddHotelController.h.

@interface AddHotelController : UIViewController
       <UITextFieldDelegate,
   ABPeoplePickerNavigationControllerDelegate,
   ABNewPersonViewControllerDelegate> {

In this case, there is only one delegate method you'll need to implement — the newPersonViewController:didCompleteWithNewPerson: method, which is invoked when the user taps Save or Cancel. By the way, if the user tapped Save, by the time you receive the message, the current Address Book has been saved to the Address Book database.

At that point, it's your job to dismiss the AbNewPersonViewController.

Add the code in Listing 1-23 to AddHotelController.m to do just that.

- (void)newPersonViewController:
  (ABNewPersonViewController *)newPersonViewController
            didCompleteWithNewPerson:(ABRecordRef)person {

  [self dismissModalViewControllerAnimated:YES];
}

Now they you've gotten that out of the way, you can concentrate on what you need to do to actually add the new contact. Adding a contact to the iPhone's Address Book isn't horribly complicated, but there's some work to do.

To start, you need to implement the IBAction saveToContacts: method — that's where the work will get done.

Add the code in Listing 1-24 to AddHotelController.m.

- (IBAction) saveToContacts:(id)sender{

  ABAddressBookRef addressBook = ABAddressBookCreate();
  ABRecordRef personRecord = ABPersonCreate();

  ABRecordSetValue(personRecord, kABPersonOrganizationPropert
   y,name.text, nil);
  ABRecordSetValue(personRecord,
               kABPersonLastNameProperty,name.text,nil);

  ABMutableMultiValueRef mutableMultiValueRef =
   ABMultiValueCreateMutable
                        (kABMultiDictionaryPropertyType);
  NSMutableDictionary *addressDictionary =
   [[NSMutableDictionary alloc] init];
 [addressDictionary setObject:street.text forKey:(NSString
  *) kABPersonAddressStreetKey];
 [addressDictionary setObject:city.text
             forKey:(NSString *)kABPersonAddressCityKey];
 [addressDictionary setObject:state.text
            forKey:(NSString *)kABPersonAddressStateKey];
 [addressDictionary setObject:zip.text
              forKey:(NSString *)kABPersonAddressZIPKey];
 ABMultiValueAddValueAndLabel(mutableMultiValueRef,
                   addressDictionary, kABWorkLabel, nil);
 ABRecordSetValue(personRecord, kABPersonAddressProperty,
                              mutableMultiValueRef, nil);
 CFRelease(mutableMultiValueRef);
 ABAddressBookAddRecord(addressBook, personRecord, nil);
 ABAddressBookSave(addressBook, nil);

ABNewPersonViewController *picker =
                 [[ABNewPersonViewController alloc] init];
   picker.newPersonViewDelegate = self;
   picker.displayedPerson = personRecord;

   UINavigationController* navigationController =
    [[UINavigationController alloc] initWithRootViewController
    :picker];
   [self presentModalViewController:navigationController
    animated:YES];
   [picker release];
 }

To create a new Address Book entry, start by creating a new Address Book with data from the Address Book database.

ABAddressBookRef addressBook = ABAddressBookCreate();

When you have the Address Book, you'll create the new record you want to add to it.

ABRecordRef personRecord = ABPersonCreate();

Then you'll add the data to the new record.

For single-value rewords, like name, you'll do something similar to what you did when you accessed the Address Book information back in the last section. But in this case, instead of ABRecordCopyValue you'll use ABRecordSetValue. (Kind of makes sense doesn't it?)

ABRecordSetValue(personRecord, kABPersonOrganizationProperty,
   name.text, nil);
ABRecordSetValue(personRecord,
   kABPersonLastNameProperty,name.text, nil);

This code sets the Organization and Last Name fields with the text from the Name field in the view. The last argument is a place to return any errors, but throughout this code I use nil — but feel free to explore that on your own.

Next in line in Listing 1-24 is adding a new address record. (I'll skip the phone number multi-value property type — but you get the drift.) To add a new address record, you create a new dictionary property type and then a new dictionary. In this case, you're creating an ABMutableMultiValueRef instead of the multiValueRef you used when you read the contact information in the previous section. It needs to be mutable because you're going to making changes to it.

ABMutableMultiValueRef mutableMultiValueRef =
ABMultiValueCreateMutable(kABMultiDictionaryPropertyType);
NSMutableDictionary *addressDictionary =
                       [[NSMutableDictionary alloc] init];

Then, you go on to add the fields you're interested in to the dictionary:

[addressDictionary setObject:street.text
          forKey:(NSString *) kABPersonAddressStreetKey];
  [addressDictionary setObject:city.text
             forKey:(NSString *)kABPersonAddressCityKey];
  [addressDictionary setObject:state.text
            forKey:(NSString *)kABPersonAddressStateKey];
  [addressDictionary setObject:zip.text
             forKey:(NSString *)kABPersonAddressZIPKey];

Then you add the value (addressDictionary) and the label (kABWorkLabel) to the property (mutableMultiValueRef):

ABMultiValueAddValueAndLabel(mutableMultiValueRef,
   addressDictionary, kABWorkLabel, nil);

and set it as the value of the property (kABPersonAddressProperty) in the personRecord and release the dictionary:

ABRecordSetValue(personRecord, kABPersonAddressProperty,
   mutableMultiValueRef,nil);
CFRelease(mutableMultiValueRef);

Then you add the person record to the Address Book you created and then save it, which actually updates the database:

ABAddressBookAddRecord(addressBook, personRecord, nil);
ABAddressBookSave(addressBook, nil);

Finally, you create the controller, set self as the delegate, give it the person record to display, and then modally present the controller:

ABNewPersonViewController *picker =
   [[ABNewPersonViewController alloc] init];
picker.newPersonViewDelegate = self;
picker.displayedPerson = personRecord;
UINavigationController* navigationController =
   [[UINavigationController alloc]
                    initWithRootViewController:picker];
self presentModalViewController:navigationController
                                         animated:YES];
[picker release];

There's a lot more functionality here that I haven't coverd — updating an existing records comes to mind, as well as the ability for your application to be notified when another application makes changes to the Address Book database. I'll leave it up to you to explore that on your own.