Codefile [KeyboardInputs.zip] available for download at Wrox.com

How It Works

The beauty of the iPhone user interface is that when the system detects that the current active view is a TextField view, the keyboard automatically appears; you don't need to do anything to bring up the keyboard. Using the keyboard, you can enter alphanumeric data as well as numbers and special characters (such as symbols). The keyboard in iPhone also supports characters of languages other than English, such as Chinese, Hebrew, and others.

Unfortunately, making the keyboard go away is not as straightforward as making it appear. When you are done with the input, the keyboard does not go away automatically. This is because it does not know when you are done with the input; to do so you need to write some code. You will learn how to do this in the section "Making the Keyboard Go Away."

Codefile [ScrollingViews.zip] available for download at Wrox.com

Figure 5.24. Figure 5-24

How It Works

This example demonstrates the various ways in which you can detect the presence of a keyboard and how the view involved can be relocated so that it is not covered by the keyboard.

First, you declare three private variables:

//---size of keyboard---
CGRect keyboardBounds;

//---size of application screen---
CGRect applicationFrame;

//---original size of ScrollView---
CGSize scrollViewOriginalSize;

The keyboardBounds is used to store the size of the keyboard (in particular, to obtain the height of the keyboard). Although you can always hard-code the height of the keyboard to be 216, I don't recommend doing so because the size of the keyboard may change at a later time. A better practice is to dynamically obtain the size of the keyboard during runtime.

The applicationFrame is used to store the size of the screen. As with obtaining the size of the keyboard, it is always better to obtain this figure dynamically during runtime.

The scrollViewOriginalSize is used to save the original size of the ScrollView view. Doing so allows you to restore the ScrollView to its original size after the user is done with the editing (at which time all the views need to be moved back to their original positions).

When the View is loaded, you first save the size of the ScrollView view as well as obtain the size of the screen:

-(void) viewDidLoad {
    scrollViewOriginalSize = scrollView.contentSize;
    applicationFrame = [[UIScreen mainScreen] applicationFrame];
    [super viewDidLoad];
}

In the viewWillAppear: event (this method is invoked before the View appears on-screen), you register for the two notifications — UIKeyboardWillShowNotification and UIKeyboardWillHideNotification. When the keyboard appears (UIKeyboardWillShowNotification), the keyboardWillShow: method is invoked. When the keyboard disappears, the keyboardWillHide: method is invoked:

-(void) viewWillAppear:(BOOL)animated
{
    //---registers the notifications for keyboard---
    [[NSNotificationCenter defaultCenter]
         addObserver:self
         selector:@selector(keyboardWillShow:)
         name:UIKeyboardWillShowNotification
         object:self.view.window];

    [[NSNotificationCenter defaultCenter]
         addObserver:self

selector:@selector(keyboardWillHide:)
         name:UIKeyboardWillHideNotification
         object:nil];
}

Before the view disappears, you remove the notifications you had previously set:

-(void) viewWillDisappear:(BOOL)animated
{
    //---removes the notifications for keyboard---
    [[NSNotificationCenter defaultCenter]
         removeObserver:self
         name:UIKeyboardWillShowNotification
         object:nil];

    [[NSNotificationCenter defaultCenter]
         removeObserver:self
         name:UIKeyboardWillHideNotification
         object:nil];
}

When you click a TextField view, the keyboardWillShow: method is invoked. With this method, you try to obtain the size of the keyboard by passing a reference to the keyboardBounds variable:

//---when the keyboard appears---
-(void) keyboardWillShow:(NSNotification *) notification
{
    //---gets the size of the keyboard---
    NSDictionary *userInfo = [notification userInfo];
    NSValue *keyboardValue = [userInfo objectForKey:UIKeyboardBoundsUserInfoKey];
    [keyboardValue getValue:&keyboardBounds];
}

After the keyboard is displayed, the textFieldDidBeginEditing: method is invoked. With this method, you know which TextField view is being edited and you are now ready to move the ScrollView view so that the TextField view can be centered in the remaining visible space not covered by the keyboard. You perform the scrolling by calling the moveScrollView: method, which you define next:

//---when a TextField view begins editing---
-(void) textFieldDidBeginEditing:(UITextField *)textFieldView {
    [self moveScrollView:textFieldView];
}

In the moveScrollView: method, you calculate the number of pixels to scroll and then get the ScrollView view to scroll the views contained within it until the TextField view currently being edited is at the center of the visible area of the screen:

-(void) moveScrollView:(UIView *) theView {

    //---get the y-coordinate of the view---
    CGFloat viewCenterY = theView.center.y;

    //---calculate how much visible space is left---

CGFloat freeSpaceHeight = applicationFrame.size.height -
                          keyboardBounds.size.height;

    //---calculate how much the scrollview must scroll---
    CGFloat scrollAmount = viewCenterY - freeSpaceHeight / 2.0;

    if (scrollAmount < 0)  scrollAmount = 0;

    //---set the new scrollView contentSize---
    scrollView.contentSize = CGSizeMake(
                             applicationFrame.size.width,
                             applicationFrame.size.height +
                                 keyboardBounds.size.height);

    //---scroll the ScrollView---
    [scrollView setContentOffset:CGPointMake(0, scrollAmount) animated:YES];
}

When the TextField view resigns its First Responder status, the textFieldDidEndEditing: method will be invoked. At this point, you restore the ScrollView view to its original content size:

//---when a TextField view is done editing---
-(void) textFieldDidEndEditing:(UITextField *) textFieldView {
    [UIView beginAnimations:@"back to original size" context:nil];
    scrollView.contentSize = scrollViewOriginalSize;
    [UIView commitAnimations];
}

A noteworthy point to highlight here is that you use the beginAnimations method of the UIView class to animate the ScrollView view in the process of restoring to its original size. If you do not use this method, the ScrollView will very abruptly restore to its original size, causing a flicker.

Just before the keyboard disappears, the keyboardWillHide: method is invoked. In this case, you don't have much to do:

//---when the keyboard disappears---
-(void)keyboardWillHide:(NSNotification *) notification
{
}

Finally, in the dealloc method, you release all the outlets you have created:

-(void) dealloc {
    [textField release];
    [scrollView release];
    [super dealloc];
}

Earlier, you saw how you can connect an IBAction with the Did End On Exit event of a TextField view to hide the keyboard when the user presses the Return key. Alternatively, you can also implement the textFieldShouldReturn: method. This method is invoked whenever the user presses the Return key on the keyboard:

-(BOOL) textFieldShouldReturn:(UITextField *) textFieldView {
    if (textFieldView == textField){
        [textField resignFirstResponder];
    }
    return NO;
}