The giveaway works like this:

Each Monday in November I’ll write a tip that is based on ideas and code in the book. Through out the week, you can register for the book giveaway by referring a friend to the tip. The deadline to enter the drawing for the week ends on Thursdays, at 6:00PM CST.

I will then draw a name from those who registered and announce the winner on each Friday in November

Winner for this week

The winner of the eBook for this week is: Bill Mietelski – here’s a little more about Bill:

“I’m currently a Software Engineer at a leading national academic medical center in the Chicagoland area, working on statistical research studies. I heard about your website & the eBook giveaway on Twitter (via @OReillyMedia).”

“I don’t have an iPhone (yet) but I’m thinking about pulling the trigger soon. I’m a *huge* fan of O’Reilly’s Head First series of books, and I couldn’t think of a better way to get started than with a copy of Head First iPhone Development, so I entered the giveaway.”

“Now that I have the book, maybe you can have an actual iPhone giveaway :-)”

Bill sent me an impressive picture of his collection of O’Reilly books. I thought I had a nice collection, however, looks like I have some catching up to do.

Congratulations Bill!

Thank you to everyone who registered in the drawing. If you didn’t win this week, please visit iPhone Developer Tips again on Monday the 9th for another tip from Head First iPhone Development, and you can register in the drawing for Friday, November 13th.

URL to Remote Image

We start by creating a URL to the remote resource:

NSURL *url = [NSURL URLWithString: 
   @"http://iphonedevelopertips.com/images/logo-iphone-dev-tips.png"];

Create UIImage from NSData

The next step is to build a UIImage using the data downloaded from the URL, which consists of an NSData object that holds the remote image contents:

UIImage *image = [UIImage imageWithData: [NSData dataWithContentsOfURL:url]];

Putting it Together

Here’s how to wrap it all together, adding the remote image as a subview to an existing view by creating a UIImageView from the above UIImage:

NSURL *url = [NSURL URLWithString: 
   @"http://iphonedevelopertips.com/images/logo-iphone-dev-tips.png"];
UIImage *image = [UIImage imageWithData: [NSData dataWithContentsOfURL:url]]; 
[self.view addSubview:[[UIImageView alloc] initWithImage:image]];

Book Giveaway – Every Friday in November

O’Reilly and iPhone Developer Tips are collaborating to give away a free ebook (electronic copy) of Head First iPhone Development each Friday in November. You can register in this weeks drawing by referring a friend to this tip – see the Refer-a-Friend button near the bottom of this post.

UITextField Hidden by Keyboard

Have you ever had one or more textfields on screen, that when tapped, become hidden by the on-screen keyboard? This tip will show an example of how to adjust textfields that are contained within a scrollview such that they are always visible, even when entering text.

The inspiration for this tip comes from Chapter 6, Saving, Editing and Sorting Data. The code example in the book is created over a series of chapters – to provide a complete working example for this tip, I’ll write a small working example from the ground up that you can download and build using Xcode. I’ll write all the code for the UI without Interface Builder, which will provide a little more insight into how all the pieces fit together.

The UI Problem

Let’s get started – When working with UITextFields, depending on the layout of your screen, good chance the keyboard will overlay your textfield when a user taps on the field to start editing. For example, the screenshot below shows two textfields, both displayed within a scrollview.

When the user selects either textfield, the keyboard will appear, trouble is, the keyboard may overlay the textfields as shown here:

Scrollview with Two UITextFields

For this code example, I’ll wrap two UITextFields inside a scrollview. When the keyboard is shown, the scrollview size is adjust based on the size of the keyboard, allowing the textfield selected to be visible on the display.

Let’s look at the view controller that will contain the textfields and the scrollview:

@interface test_appViewController : UIViewController  <UIScrollViewDelegate, UITextFieldDelegate>
{
  BOOL           keyboardVisible;
  CGPoint        offset;
  UIScrollView  *scrollview;
  UITextField    *textfield;
  UITextField    *textfield2;
}

The variable keyboardVisible will keep the state of whether or not the keyboard is visible. The variable offset will keep track of current offset of the scrollview, before the keyboard is shown, so when the keyboard is dismissed, we can return the scrollview to its original position.

UI Layout

The code that follows show the layout of the user interface, a view that contains a scrollview, which in turn, contains two textfields.

#define SCROLLVIEW_HEIGHT 460
#define SCROLLVIEW_WIDTH  320
 
#define SCROLLVIEW_CONTENT_HEIGHT 720
#define SCROLLVIEW_CONTENT_WIDTH  320
 
...
 
- (id)init
{
  if (self = [super init]) 
  {
    self.view = [[[UIView alloc] initWithFrame:[[UIScreen mainScreen] applicationFrame]] autorelease];
    self.view.backgroundColor = [UIColor whiteColor];
 
    // Create scrollview
    scrollview = [[UIScrollView alloc] init];      
    scrollview.contentSize = CGSizeMake(SCROLLVIEW_CONTENT_WIDTH, SCROLLVIEW_CONTENT_HEIGHT);
    scrollview.frame = CGRectMake(0, 0, SCROLLVIEW_WIDTH, SCROLLVIEW_HEIGHT);
    scrollview.scrollsToTop = NO;
    scrollview.delegate = self;
    [self.view addSubview:scrollview];
 
    // Create textfield 1
    textfield = [[UITextField alloc] initWithFrame:CGRectMake(20, 240, 280, 30)];
    textfield.placeholder = @"Textfield 1";
    textfield.delegate = self;
    textfield.returnKeyType = UIReturnKeyDone;
    textfield.borderStyle = UITextBorderStyleBezel;
    textfield.enablesReturnKeyAutomatically = TRUE;
    [scrollview addSubview:textfield];  
 
    // Create textfield 2
    textfield2 = [[UITextField alloc] initWithFrame:CGRectMake(20, 290, 280, 30)];
    textfield2.placeholder = @"Textfield 2";
    textfield2.delegate = self;
    textfield2.returnKeyType = UIReturnKeyDone;
    textfield2.borderStyle = UITextBorderStyleBezel;
    textfield2.enablesReturnKeyAutomatically = TRUE;
    [scrollview addSubview:textfield2];  
  }
 
  return self;  
}

Keyboard Notifications

The magic behind all of this begins by registering to receive notifications when the keyboard is shown and when it is hidden. You can read more about notifications on this iPhone Developer Tip: Basics of Notifications.

To add the notifications for the keyboard, here’s all we need to do:

[[NSNotificationCenter defaultCenter] addObserver:self
   selector:@selector (keyboardDidShow:)
   name: UIKeyboardDidShowNotification object:nil];
 
[[NSNotificationCenter defaultCenter] addObserver:self 
   selector:@selector (keyboardDidHide:)
	name: UIKeyboardDidHideNotification object:nil];

These calls request that the methods keyboardDidShow and keyboardDidHide be called when the notifications UIKeyboardDidShowNotification and UIKeyboardDidHideNotification, respectively, are fired.

Keyboard Visible Code

The OS will trigger the notification UIKeyboardDidShowNotification when a user taps in a textfield, which will in turn call the method shown below. The first check is to see if the keyboard is currently visible, if so, we’re done. If not, access the dictionary for the notification so we can get to the keyboard size – this is important as the keyboard size can vary depending on the textfield.

With the keyboard size known, we can now adjust (shrink) the scrollview frame so the keyboard and scrollview share the screen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

-(void) keyboardDidShow: (NSNotification *)notif 
{
  // If keyboard is visible, return
  if (keyboardVisible) 
  {
    NSLog(@"Keyboard is already visible. Ignoring notification.");
    return;
  }
 
  // Get the size of the keyboard.
  NSDictionary* info = [notif userInfo];
  NSValue* aValue = [info objectForKey:UIKeyboardBoundsUserInfoKey];
  CGSize keyboardSize = [aValue CGRectValue].size;
 
  // Save the current location so we can restore
  // when keyboard is dismissed
  offset = scrollview.contentOffset;
 
  // Resize the scroll view to make room for the keyboard
  CGRect viewFrame = scrollview.frame;
  viewFrame.size.height -= keyboardSize.height;
  scrollview.frame = viewFrame;
 
  // Keyboard is now visible
  keyboardVisible = YES;
}

One line of code to point is line 17, where we save the current offset of the scrollview so we can restore the position once the keyboard is hidden.

Keyboard Hidden Code

Upon dismissing the keyboard, the code below will be called. The basic idea is to reset the size of the scrollview to its original size, and follow this by updating the scrollview offset to where it was prior to the keyboard being shown.

-(void) keyboardDidHide: (NSNotification *)notif 
{
  // Is the keyboard already shown
  if (!keyboardVisible) 
  {
    NSLog(@"Keyboard is already hidden. Ignoring notification.");
    return;
  }
 
  // Reset the height of the scroll view to its original value
  scrollview.frame = CGRectMake(0, 0, SCROLLVIEW_WIDTH, SCROLLVIEW_HEIGHT);
 
  // Reset the scrollview to previous location
  scrollview.contentOffset = offset;
 
  // Keyboard is no longer visible
  keyboardVisible = NO;	
}

Final User Interface

The end result is shown below – when the keyboard is shown, the scrollview is adjusted to the textfields are visible.

Xcode Project Source Code

You can download the Xcode project with source code here.

Book Giveaway

Sorry, the drawing for the free ebook is now closed.

Point to the Documents Directory

Each application has its own sandbox in which you can read/write files. Files written to the sandbox are persistent across invocations of the application, including across application updates.

You can locate the Documents directory in the sandbox as shown below:

// For error information
NSError *error;
 
// Create file manager
NSFileManager *fileMgr = [NSFileManager defaultManager];
 
// Point to Document directory
NSString *documentsDirectory = [NSHomeDirectory() 
         stringByAppendingPathComponent:@"Documents"];

Creating a File

With the documents directory available, we can now use that path to create a new file in the sandbox and write a few lines of text:

// File we want to create in the documents directory 
// Result is: /Documents/file1.txt
NSString *filePath = [documentsDirectory 
         stringByAppendingPathComponent:@"file1.txt"];
 
// String to write
NSString *str = @"iPhone Developer Tips\nhttp://iPhoneDevelopTips,com";
 
// Write the file
[str writeToFile:filePath atomically:YES 
         encoding:NSUTF8StringEncoding error:&error];
 
// Show contents of Documents directory
NSLog(@"Documents directory: %@",
         [fileMgr contentsOfDirectoryAtPath:documentsDirectory error:&error]);

We build a path to the file we want to create (file1.txt), initialize a string to write into the file, and write out the contents. The last line shows a directory listing of what is in the Documents directory after we create the file, see the figure below:

Renaming a File

To rename a file we move the file to a new path. The code below creates the destination path we are after, requests to move the file, and shows the Documents directory after the move.

// Rename the file, by moving the file
NSString *filePath2 = [documentsDirectory 
                                 stringByAppendingPathComponent:@"file2.txt"];
 
// Attempt the move
if ([fileMgr moveItemAtPath:filePath toPath:filePath2 error:&error] != YES)
  NSLog(@"Unable to move file: %@", [error localizedDescription]);
 
// Show contents of Documents directory
NSLog(@"Documents directory: %@", 
         [fileMgr contentsOfDirectoryAtPath:documentsDirectory error:&error]);

After moving the file, the output should look similar to the image below:

Deleting a File

To round out this tip, let’s look at how to delete a file:

// Attempt to delete the file at filePath2
if ([fileMgr removeItemAtPath:filePath2 error:&error] != YES)
  NSLog(@"Unable to delete file: %@", [error localizedDescription]);
 
// Show contents of Documents directory
NSLog(@"Documents directory: %@",
         [fileMgr contentsOfDirectoryAtPath:documentsDirectory error:&error]);

Once the file is deleted, as expected, the Documents directory is now empty:

These examples touch the surface of working with files. Check out the documentation for NSFileManager for all the specifics.

In a previous post I wrote about my experience using iSimulate in an iPhone project I was working on at that time: Testing Multi-Touch, Accelerometer and GPS using the Xcode Simulator. In addition iPhone Developer Tips hosted a contest for a free copy of iSimulate: iSimulate Giveaway.

In a nutshell, iSimulate is an iPhone application that sends multi-touch events, accelerometer data and GPS location information to the iPhone Simulator wirelessly, which is very handy, as the Xcode simulator does not offer such support to exercise your code.

The latest release of iSimulate, includes support for streaming your application as video to a device as well as recognizing orientation changes and notifying your application running in the iPhone Simulator.

iSimulate consists of an SDK library, which is free, that creates a listening server in the simulator that communicates with an iPhone/iPod running the iSimulate client. The client captures all data from the accelerometer sensor, the touch events, the location and device ID and streams them to the server. The iSimulate client is available for purchase on the App Store.

iSimulate is a great addition to any iPhone Developer’s toolbox.

I’ve found another good use for UIActionSheet, to show text messages with minimal coding and overhead. You might use this idea to show content sensitive help text, or maybe display a message that is shown only once upon the first run of an application.

You can get an idea of the look that I’m after from the figure below. In this example I’m showing nothing more than three paragraphs of text and a button to dismiss the view.

It’s almost embarrassing to show the code as there’s really nothing to it:

    UIActionSheet *msg = [[[UIActionSheet alloc] 
        initWithTitle:@"Lorem ipsum dolor...text goes here" 
        delegate:nil 
        cancelButtonTitle:nil  destructiveButtonTitle:nil 
        otherButtonTitles:@"Okay", nil] 
        autorelease];
    [msg showInView:window];

We have no need for a delegate in this case, and by setting all but the “Okay” button to nil, we have just one button.

The beauty of using a UIActionSheet for this type of information is that presentation is handled for you (sliding into place), all other UI elements are obscured (a modal presentation) and it’s ridiculously simple to implement.

I’ve written previously on How to Suspend / Ignore Touch Events, which is as simple as:

// Begin ignoring events
[[UIApplicationsharedApplication] beginIgnoringInteractionEvents];
 
// Stop ignoring events
[[UIApplicationsharedApplication] endIgnoringInteractionEvents];

The problem with the above is that depending on when and where you make these calls, you can end up with the lines sprinkled about inside your code, which can make it troublesome to match one call with the other.

For example, if I make a call to begin ignoring events, and then move to a new view in which I then make a request to stop ignoring events, I now have the begin ignorning call in a different class from the end ignorning call. A big deal? Definitely not, however, when you see one call without the other, it can be both hard to know if you have a matching set, not to mention the questions that may arise when you revisit your code a few months down the road.

I get around this by writing a very simple set of methods for stopping and stopping the ignore events process. Here’s how this looks:

Interface Definition for SomeClass

@interface SomeClass : NSObject 
{
  ...
}
 
+ (void)enableEvents;
+ (void)startIgnoringEvents;
+ (void)stopIgnoringEventsAfter:(int)seconds;

Notice that the three methods shown are class methods. The implementation for SomeClass follows:

Implementation for SomeClass

@implementation SomeClass
 
...
 
+ (void)enableEvents
{
  [[UIApplication sharedApplication] endIgnoringInteractionEvents];
}
 
+ (void)startIgnoringEvents
{
  [[UIApplication sharedApplication] beginIgnoringInteractionEvents];
}
 
+ (void)stopIgnoringEventsAfter:(int)seconds
{
  [self performSelector:@selector(enableEvents) withObject:nil afterDelay:seconds];
}
 
@end

How to Start and Stop Ingoring Events

Now that I have these helper methods, I can keep all references to start and stop ignoring of events in one place, here’s how this might look:

// Stop events momentarily...
[SomeClass startIgnoringEvents];    
 
// This is the activity I don't want interrupted
[dropDownViewController showMsg];
 
// Stop ignoring events
[ShoppingListViewController stopIgnoringEventsAfter:2];

Again, these extra steps are not required, however, keeping related code together can be a good thing.

This is the first post of what I hope is many where we can share tips and tricks on working with Xcode.

Tip #1 – Split Editor View Vertically

If you like to have multiple code windows open at once, the Split Editor option is your friend (see the little square grid icon shown below).

By default, the windows are split horizontally. If you prefer to view your code side-by-side (nice for comparing), here’s how to tell the split to be vertical

1. Hold down Option key when clicking the Split Window icon

Tip #2 – Comment Out a Block of Code

You can quickly comment out a block of code as follows:

1. Select one or more lines of code to comment
2. Command-/

To uncomment a block of code, repeat the steps above.

Tip #3 – Toggle Between .h and .m Files (aka Switch to Counterpart)

Within your current code window, you can swap between the .h and .m file as follows:

1. Command-Option Up-Arrow

Tip #4 – Map Keys to Actions (Key Bindings)

The Switch to Counterpart tip above is a real time saver. However, I often find that if I map logical key-strokes to actions I’m much more likely to get into the habit of using them. For example, I mapped the Switch to Counterpart to Option-S, as in Swap or Switch.

Here’s how to set key bindings in Xcode

1. From the Xcode menu choose Prefereces
2. Select Key Bindings
3. Click on one of the Actions in the list
4. Tap on the Keys column on the right
5. Enter the keystroke you want to map to the action
6. Click Ok to save your changes

Tip #5 – Jump to API Documentation

Showing relevant API documentation for anything within the SDK(s) is as simple as:

1. Option Double-Click on relevant code

For example, in the screenshot below, after Option double-clicking on UIToolbar, a popup window shows a summary of the class information.

Tip #6 – Traverse File History

As you open and edit various files, Xcode keeps a history list of your actions, not unlike when using a web-browser. You can move through the list using the directional arrows as shown below:

The keystoke equivalent for the above is:

1. Option-Command Left-Arrow goto to previous file
2. Option-Command Right-Arrow goto to next file

Tip #7 – Set a Bookmark

I can’t imagine coding without having the option to set a bookmark as a placeholder for what I’m working on. I do this regularly when I need to segue to another file to find a snippet or otherwise poke around outside the current file I’m working on.

Setting a bookmark is as simple as:

1. Control-D
2. Enter a name for the bookmark

Tip #8 – Jump to Bookmark

There are two options to jump to a bookmark. First, you can select the bookmark icon in the upper right corner of the Editor window.

You can bring up the same menu as shown in the above figure using this keystoke:

1. Control-4

Tip #9 – Indent / Un-indent Code

You can indent a line of code or a selected block of code as follows:

1. Command-[ move code left
2. Command-] move code right

The above works regardless of where you are in a line of code, in other words, you don’t have to be at the beginning of the line.

Tip #10 – Zoom Editor

You can toggle between Detail view and Editor view by clicking the Editor button as shown here:

The keystroke equivalent of the above is:

1. Shift-Command-E

Have an Xcode Tip to Share?

If you have a favorite tip or trick, please post a comment or send tips to me here. Killer Xcode Tips and Tricks – Tips 11 to 20 will be posted next week, and suggestions are welcome!

Start by creating a variable of type NSTimeInterval to hold the time the touch event began.

// Define this as an instance variable
NSTimeInterval touchStartTime;
 
-(void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event;
{
  // When the touch event was detected
  touchStartTime = [event timestamp];
}

Inside the touchesBegan event, with some simple math, one can determine how long from the start event to the end.

-(void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event;
{
  // Calculate how long touch lasted
  NSTimeInterval touchTimeDuration = [event timestamp] - touchStartTime;
 
  NSLog(@"Touch duration: %3.2f seconds", touchTimeDuration);
}

Path to Xcode Simulator Files

The path to the simulator files is here:

/Users/USER_NAME/Library/Application Support/iPhone Simulator/User/Applications

USER_NAME is the current user logged in on the machine. There is a unique identifier created by the simulator, one value for each application. The figure below shows how this looks on my machine, notice there are two entries in the Applications folder, one for each of the current applications I am working on.

In the application App-Vol1 you can see that I am creating a custom plist file Favorites.plist and storing the file in the Documents directory. This is the file I referred to earlier that I update whenever the user quits the application.

Easy Access to Simulator Files

To make access to the simulator files quick and easy, I keep an entry on the left side of Finder titled iPhone Simulator. Simply navigate your way to the simulator files and drag/drop the folder on the left sidebar. You can rename this folder by right-clicking and choosing Rename.