The first thing you need to decide is where you plan on gathering and then using the user's preferences. In this example, the preferences are a) the text for the falling words, and b) the speed of the animation. The obvious place to use the preferences data is MainViewController.m, where it sets fallingWords and speed (refer to the listing for MainViewController.m in Chapter 3 of this minibook):

fallingWords = [[NSString alloc] initWithString:@"Peace Love
   Groovy Music"];
speed = 10.0;

And the obvious place to gather the preferences data is in the Flipside view, where the user enters the replacement text for fallingWords and changes the speed — and this would be in FlipsideViewController.m, as you see in this chapter. (Don't forget: I also show you how to offer these preference settings through the Settings app.)

It's really easy to both access and update a preference — as long as you have NSUserDefaults by your side. The trick here is to use the NSUserDefaults class to read and update the replacement text and speed. NSUserDefaults is implemented as a singleton, meaning there's only one instance of NSUserDefaults running in your application. To get access to that one instance, you invoke the class method standardUserDefaults:

[NSUserDefaults  standardUserDefaults]

standardUserDefaults returns the NSUserDefaults object. As soon as you have access to the standard user defaults, you can store data there and then get it back when you need it. To store data, you simply give it a key and tell it to save the data using that key.

The way you tell it to save something is by using the setObject;forKey: method. In case your knowledge of Objective-C is a little rusty (or not there at all), that's the way any message that has two arguments is referred to.

The first argument, setObject:, is the object you want NSUserDefaults to save. This object must be NSData, NSString, NSNumber, NSDate, NSArray, or NSDictionary. In this case, savedData is an NSString, so you're in good shape.

The second argument is forKey:. In order to get the data back, and in order for NSUserDefaults to know where to save it, you have to be able to identify it to NSUserDefaults. You can, after all, have a number of preferences stored in the NSUserDefaults database, and the key tells NSUserDefaults which one you are interested in.

The particular keys you will use are kWordsOfWisdom for the falling words replacement text, kSpeed for the animation speed, and kMaxSpeed for the maximum speed possible. (Assuming you use a slider on the Flipside view to set the speed, the maximum speed is the far right point on the slider.)

To use keys like kWordsOfWisdom, kSpeed, or kMaxSpeed, you need to define them in a Constants.h file. To implement the Constants.h file in your project, do the following:

Figure 4-1. Create an empty file.

Figure 4-2. Name the new file.

Figure 4-3. The empty Constants.h file.

With a new home for your constants all set up and waiting, all you have to do is add the constants you need, as shown in Figure 4-4:

#define kWordsOfWisdom  @"wordsOfWisdomPreference"
#define  kSpeed         @"speedPreference"
#define  kMaxSpeed      20.0

Having a Constants.h file in hand is great, but you have to let MainViewController.m know that you plan to use it, as I show in the next section.

Figure 4-4. Define the keys in the Constants.h file.

For openers, you have to add a Settings bundle to your application. Here are the moves:

Figure 4-6. The Settings bundle appears in Groups & Files.

Property lists are widely used in iPhone apps because they provide an easy way to create structured data using named values for a number of object types.

Property lists all have a single root node — a dictionary, which means it stores items using a key-value pair, just as an NSDictionary does: All dictionary entries must have both a key and a value, as I describe in Chapter 4 of Book II. In this dictionary, there are two keys (refer to Figure 4-6):

The value for the first entry is a string — the name of a strings table used for localization, which I don't get into here. The second entry is an array of dictionaries — one dictionary for each preference. PreferenceSpecifiers is where you put the user preferences, which in this case are the text entered by the user for fallingWords and the animation speed selected on a slider by the user for speed. Here's how you'd get PreferenceSpecifiers to do that for you:

To see how your DeepThoughts app makes do with user preferences set within the Settings app, build and run your project as I describe in the last part of Chapter 3 of this minibook. When the iPhone Simulator appears and the app starts running, quit the app by clicking the Home button on the iPhone Simulator. Then drag to the right across the screen of the Simulator to go to the first Home screen, which contains the Settings app, as shown in Figure 4-11.

Figure 4-11. Run the Settings app in the iPhone Simulator.

Click the Settings icon to launch the Settings app, and you can then click DeepThoughts in the menu of app settings, as shown in Figure 4-12.

The settings now appear in the DeepThoughts settings screen. Click the Phrase entry field (to simulate a user touching the field), and the onscreen keyboard appears for typing the replacement text for fallingWords, as shown in Figure 4-13. You can also click and drag the slider (to simulate a user touching and sliding the slider) to set the value for speed.

Figure 4-12. Choose Deep- Thoughts in the Settings app.

Figure 4-13. Change the entry in the Phrase field with the keyboard and slide the slider for the speed.

Click Settings in the top-left corner to return to the Settings menu, and then click the Home button to quit Settings. Drag across the Home screen to the left to switch to the next screen, which contains the DeepThoughts app. Click DeepThoughts to run it again, and the changes made in Settings should change the text and speed, as shown in Figure 4-14.

Figure 4-14. Run DeepThoughts to see the changes.

Warning

As you experiment with code and build and run your project, you need to delete the application and its data from the iPhone Simulator if you change anything of significance — before building and running again. The consequences of not doing so will become obvious when things don't work like you would expect them to. See Chapter 4 of Book I for details on deleting specific apps from the iPhone Simulator. For a fast reset of all apps and all data in the simulator, choose iPhone Simulator

In procedural programming — you know, all that Linux Kernel stuff — variables are generally fair game for all. But in object-oriented programming, a class's instance variables are tucked away inside an object and shouldn't be accessed directly. The only way for them to be initialized is for you to create what are called accessor methods, which allow the specific instance variable of an object to be read and (if you want) updated. Creating accessor methods is a two-step process that begins with a @property declaration, which tells the compiler that there are accessor methods. And that is what you did in the preceding section; you coded corresponding @property declarations for each IBOutlet declaration.

The methods that provide access to the instance variables of an object are called accessor methods, and they effectively get (using a getter method) and set (using a setter method) the values for an instance variable. Although you can code those methods yourself, it can be rather tedious. This is where properties come in. The Objective-C Declared Properties feature provides a simple way to declare and implement an object's accessor methods. The compiler can synthesize accessor methods according to the way you told it to in the property declaration. Objective-C creates the getter and setter methods for you by using an @property declaration in the interface file, combined with the @synthesize declaration in the implementation file.

All that being said, at the end of the day, you need to do three things in your code to have the compiler create accessors for you:

Okay, time to add the bold lines of code in Listing 4-3 to the FlipsideViewController.m implementation file.

#import "FlipsideViewController.h"
#import "MainViewController.h"
#import "Constants.h"

@implementation FlipsideViewController

@synthesize delegate , wordsOfWisdom, slider;

# pragma mark textField methods
- (BOOL)textFieldShouldBeginEditing:(UITextField *)textField
    {
  [textField setReturnKeyType:UIReturnKeyNext];
  return YES;
}

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

}

- (void)textFieldDidEndEditing:(UITextField *)textField {
  wordsOfWisdom = textField.text;

}
# pragma mark view methods
- (void)viewDidLoad {

  [super viewDidLoad];
  self.view.backgroundColor = [UIColor
   viewFlipsideBackgroundColor];

NSLog(@"Slider value %f parent value %f" ,slider.value ,
      ((MainViewController*)(self.parentViewController)).speed);
  slider.value = + kMaxSpeed - ((MainViewController*)(self.
      parentViewController)).speed; //added
  NSLog(@"Slider value %f parent value %f" ,slider.value ,
      ((MainViewController*)(self.parentViewController)).speed);
 }

 - (IBAction)done {
   if(! [theTextField.text isEqualToString: @"" ])
    wordsOfWisdom = theTextField.text; // added
    [self.delegate flipsideViewControllerDidFinish:self];
 }
 /*
  // Override to allow orientations other than the default
    portrait orientation.
  - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceO
    rientation)interfaceOrientation {
  // Return YES for supported orientations
  return (interfaceOrientation ==
    UIInterfaceOrientationPortrait);
  }
  */
 - (void)didReceiveMemoryWarning {
    // Releases the view if it doesn't have a superview.
     [super didReceiveMemoryWarning];

    // Release any cached data, images, etc that aren't in
    use.
 }

 - (void)viewDidUnload {
    // Release any retained subviews of the main view.
    // e.g. self.myOutlet = nil;
 }

 - (void)dealloc {
     [super dealloc];
 }
 @end

Although the @property declaration in the previous section tells the compiler that there are accessor methods, they still have to be created. Fortunately, Objective-C will create these accessor methods for you whenever you include an @synthesize statement for a property:

@synthesize delegate , wordsOfWisdom, slider;

The @synthesize statement tells the compiler to create accessor methods for you — one for each @property declaration.

Next, you add the text field methods to obtain the wordsOfWisdom:

# pragma mark textField methods
- (BOOL)textFieldShouldBeginEditing:(UITextField *)textField
    {
  [textField setReturnKeyType:UIReturnKeyNext];
  return YES;
}
- (BOOL)textFieldShouldReturn:(UITextField *)textField {
  [textField resignFirstResponder];
   return YES;
}
- (void)textFieldDidEndEditing:(UITextField *)textField {
  wordsOfWisdom = textField.text;
}

The UITextFieldDelegate protocol defines the messages sent to a text field delegate as part of the sequence of editing its text. When the user performs an action that would normally start an editing session, the text field calls the textFieldShouldBeginEditing: method first to see whether editing should actually proceed. In most circumstances, you would simply return YES from this method to allow editing to proceed.

The text field calls the textFieldShouldReturn: method whenever the user taps the Return button on the keyboard to find out whether it should process the Return — you can use this method to implement any custom behavior when the Return button is tapped, but for your purposes, you simply return YES (which is the default), although you could return NO to ignore the Return button.

After saying "yes" to this and that, the real action happens with the textFieldDidEndEditing: method, which is called after the text field resigns its first responder status to tell the delegate that editing stopped for the specified text field, so that you now have the edited wordsOfWisdom.

Next, you modify the viewDidLoad method to obtain the speed from the slider (new code is in bold):

# pragma mark view methods
- (void)viewDidLoad {

[super viewDidLoad];
  self.view.backgroundColor = [UIColor
   viewFlipsideBackgroundColor];

  NSLog(@"Slider value %f parent value %f" ,slider.value ,
    ((MainViewController*)(self.parentViewController)).speed);
  slider.value = + kMaxSpeed - ((MainViewController*)(self.
    parentViewController)).speed; //added
  NSLog(@"Slider value %f parent value %f" ,slider.value ,
    ((MainViewController*)(self.parentViewController)).speed);
}
- (IBAction)done {
  if(! [theTextField.text isEqualToString: @"" ])
   wordsOfWisdom = theTextField.text; // added
  [self.delegate flipsideViewControllerDidFinish:self];
}

You wrap the code in NSLog statements to report back a message to the system log facility, but mostly this code assigns the slider.value to speed in MainViewController (which, as you recall from Chapter 3 of this minibook, uses speed to control the animated flowing text). Next, you deal with the possibility of a blank text field in the IBAction method. The code assigns the text field's text to wordsOfWisdom only if the field is not theTextField.text isEqualToString: @"".

Fine, but there are still a few problems: How will MainViewController know about the new speed assignment? How will the app save the preferences? You have to modify the MainViewController.h and MainViewController.m files by adding the code in bold, as I show in Listing 4-4 and Listing 4-5, to cover your bases here.

#import "FlipsideViewController.h"

@interface MainViewController : UIViewController
   <FlipsideViewControllerDelegate> {

  UIImage    *fallingImage;
  NSString   *fallingWords;
  double      speed;
}

- (IBAction)showInfo;
@property (readwrite)  double speed;
@end

#import "MainViewController.h"
#import "MainView.h"
#import "Constants.h"

@implementation MainViewController
@synthesize speed;

- (id)initWithNibName:(NSString *)nibNameOrNil
   bundle:(NSBundle *)nibBundleOrNil {
    if (self = [super initWithNibName:nibNameOrNil
    bundle:nibBundleOrNil]) {
        // Custom initialization
    }
    return self;
}

- (void)viewDidLoad {

  [super viewDidLoad];
  self.view.backgroundColor = [UIColor  colorWithRed:.5
   green:3 blue:.7 alpha:1];
  [NSTimer scheduledTimerWithTimeInterval:.5 target:self
   selector:@selector(onTimer) userInfo:nil repeats:YES];

//  fallingWords = [[NSString alloc] initWithString:@"Peace
   Love Groovy Music"];
//  speed = 10.0;
  if (![[NSUserDefaults standardUserDefaults]
   objectForKey:kWordsOfWisdom]) {
    [[NSUserDefaults standardUserDefaults]setObject:@"Peace
   Love Groovy Music"

   forKey:kWordsOfWisdom];
    fallingWords = @"Peace Love Groovy Music";
  }
  else {
    fallingWords = [[NSUserDefaults standardUserDefaults]
                    stringForKey:kWordsOfWisdom];
  }

  if (![[NSUserDefaults standardUserDefaults]
   objectForKey:kSpeed] ){
    [[NSUserDefaults standardUserDefaults]setDouble:10.0
   forKey:kSpeed];
    speed = kMaxSpeed-10.0;}
  else {
        speed = kMaxSpeed-[[NSUserDefaults
   standardUserDefaults] doubleForKey:kSpeed] ;
  }
}

- (void)onTimer{

  UILabel *fallingImageView = [[UILabel alloc]
   initWithFrame:CGRectMake(0, 0, 100, 30)];
  fallingImageView.text = fallingWords;
  fallingImageView.textColor = [UIColor  purpleColor];
  fallingImageView.font = [UIFont systemFontOfSize:30];
  fallingImageView.backgroundColor = [UIColor
   colorWithRed:.5 green:3 blue:.7 alpha:1];  // Transparent
   instead?
  fallingImageView.adjustsFontSizeToFitWidth = YES;

  int startX = round(random() % 80);
  int endX =  round(random() % 80);
  //speed of falling
  double randomSpeed = (1/round(random() % 100) +1) *speed;
  // image size;
  double scaleH = (1/round(random() % 100) +1) *30;
  double scaleW = (1/round(random() % 100) +1) *200;

  [self.view addSubview:fallingImageView];

  fallingImageView.frame = CGRectMake(startX, −100, scaleW,
   scaleH);

  fallingImageView.alpha = .75;

  [UIView beginAnimations:nil context:fallingImageView];
  [UIView setAnimationDuration:randomSpeed];
  [UIView setAnimationDelegate:self];
  [UIView setAnimationDidStopSelector:@selector(animationDone
   :finished:context:)];

  fallingImageView.frame = CGRectMake(endX, 500, scaleW,
   scaleH);

  [UIView commitAnimations];
}

-(void)animationDone:(NSString *)animationID
   finished:(NSNumber *)finished context:(id)context {
  UIImageView *fallingImageView = context;
  [fallingImageView removeFromSuperview];
  [fallingImageView release];
}

/*
 // Override to allow orientations other than the default
   portrait orientation.
 - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceO
   rientation)interfaceOrientation {

// Return YES for supported orientations
 return (interfaceOrientation ==
UIInterfaceOrientationPortrait);
 }
 */

- (void)flipsideViewControllerDidFinish:(FlipsideViewControl
   ler *)controller {

  if (controller.wordsOfWisdom ) {
    fallingWords = controller.wordsOfWisdom;
    [[NSUserDefaults standardUserDefaults]
   setObject:fallingWords  forKey:kWordsOfWisdom];
    [fallingWords retain];
  }

  if (controller.slider.value) {
    speed = kMaxSpeed-controller.slider.value; // can access
   it directly or use an ivar as above
    [[NSUserDefaults standardUserDefaults]setDouble:
   controller.slider.value forKey:kSpeed];
  }

    [self dismissModalViewControllerAnimated:YES];
 }
 - (IBAction)showInfo {

     FlipsideViewController *controller
      = [[FlipsideViewController alloc]
      initWithNibName:@"FlipsideView" bundle:nil];
     controller.delegate = self;
     controller.modalTransitionStyle =
      UIModalTransitionStyleFlipHorizontal;
     [self presentModalViewController:controller
      animated:YES];
     [controller release];
 }

(The rest of the code in MainViewController.m stays the same; see Chapter 3 of this minibook for the full listing.)

In Listing 4-4, you add the @property declaration for speed. Then in Listing 4-5, you add the @synthesize statement for the property.

Below the animation block in MainViewController.m (see Listing 4-5), you modify the flipsideViewControllerDidFinish: method to save the user preferences:

if (controller.wordsOfWisdom ) {
    fallingWords = controller.wordsOfWisdom;
    [[NSUserDefaults standardUserDefaults]
   setObject:fallingWords  forKey:kWordsOfWisdom];

[fallingWords retain];
  }

  if (controller.slider.value) {
    speed = kMaxSpeed-controller.slider.value; // can access
   it directly or use an ivar as above
    [[NSUserDefaults standardUserDefaults]setDouble:
   controller.slider.value forKey:kSpeed];
  }

   [self dismissModalViewControllerAnimated:YES];

As you'll recall from earlier in this chapter, you use standardUserDefaults (a NSUserDefaults class method) to gain access to the standard user defaults; you can store data there, and then get it back when you need it. To store data, you use the setObject;forKey: method. The first argument, setObject:, is the object you want NSUserDefaults to save (fallingWords); the second argument is forKey: (kWordsOfWisdom), which is how NSUserDefaults identifies it. For the slider value, setDouble: controller.slider.value forKey: sets the value of the specified default key to the double value.

The dismissModalViewControllerAnimated: method animates the view as it's dismissed. You're sending the message to the view controller that invoked the presentModalViewController method — in this case, the (IBAction)showInfo method. (Take another peek at Listing 4-5 at the end.)