Getting your app on a Phone for Debugging

To get an app on a phone for the purposes of debugging you first need to go to (in a browser): http://developer.apple.com/iphone/ and log in user your developer account or your university program account.
Once logged in you should see a bunch of links on the right-hand-side that look like:
Click on the iPhone Developer Portal link.

Getting your app on a Phone for Debugging - cont'd

In the center of the screen you should see:
Click on this link. Make sure you attach an iPhone to your computer with the usual USB sync cable.
This link guides you step by step through the process of creating a certificate signing request, adding it to your keychain, and adding a provisioning profile to your phone.

Getting your app on a Phone for Debugging - cont'd some more

Now to get an application actually on your iPhone, the Bundle Identifier in your project's Info.plist file has to match the AppId and organization you set in your certificate:
Before you compile and run your project, you should set the Active SDK in the upper left corner of the XCode window to a setting that has the word Device in it:
At this point when you compile and run, it should put the app on your phone.
One potential reason why this won't work is if your phone has a more recent OS than your SDK, in which case you should update your SDK.

Image of a Program I Wrote on an iPhone

Quiz

To make the keyboard go away after a user hits return on the iPhone, the programmer needs to:

do nothing
override the method textFieldDoneEditing
write a handler for the event Did End On Exit

Auto-Rotations

One cool aspect of the iPhone is that when you rotate the phone it can detect this and display a suitable layout of the screen (Portrait or Landscape).
In the simulator, you can use command and the arrow keys to change the orientation. Or you can select how to rotate the orientation from the hardware menu.

Specifying Rotation Support

If you use XCode to create new View Based application, in the View Controller generated of your project there should auto-magically be the commented out code:

/*
// Override to allow orientations other than the default portrait orientation.
- (BOOL)shouldAutorotateToInterfaceOrientation:
    (UIInterfaceOrientation)interfaceOrientation {
    // Return YES for supported orientations
    return (interfaceOrientation == UIInterfaceOrientationPortrait);
}
*/

This method is called by the system to find out if it's okay to rotate your app's window.
You should return YES for each supported orientation from among: UIInterfaceOrientationPortrait, UIInterfaceOrientationPortraitUpsideDown, UIInterfaceOrientationLandscapeLeft, UIInterfaceOrientationLandscapeRight.
If you want to support, all orientations then just return YES.

Making Auto-Rotated Things Look Right

To make the rotated view look correct we can open Interface Builder on the View Controller's xib file.
Select Tools > Size Inspector.
The top part controls the size and positioning of elements within the screen; the auto-sizing attributes control how the view is drawn when the window changes.
You will notice there are red arrows and I's in the square for auto-sizing.
Clicking on a UI element, and then clicking on the arrows will toggle the arrow from being solid to dashed. If it is solid then that margin/width/height attribute is considered strict; otherwise, it is considered flexible when the iPhone tries to render the screen the best it can.
Twiddling with the solid and red lines one can often make the screen look decent when rotated.

Finer Grain Control

There are a couple of ways one can improve the layout after a rotation.

One can override the method:

-(void)willAnimateSecondHalfOfRotationFromInterfaceOrientation: 
   (UIInterfaceOrientation)fromInterfaceOrientation
   duration:(NSTimeInterval)duration {
   UIInterfaceOrientation toOrientation = self.interfaceOrientation;
   
   [UIView beginAnimations:@"move my stuff" context:nil];
      //says we'd like the switch animated; give animation block a name

   if(toOrientation == UIInterfaceOrientationPortrait || 
     toOrientation == UIInterfaceOrientationPortraitUpsideDown) {
     myScreenComponent.frame = CGRectMake(x,y,width, height);
     // ...
   } else {
     myScreenComponent.frame = CGRectMake(xlandscape,ylandscape, width_ls, height_ls);
     // ...

   }

   [UIView commitAnimations];
   // our animation clock is finished

}

The second way is to design two views. One for portrait one for landscape and switch between them.

Some Comments on Using Two Views

To have your controller be responsible for two views, in IB, you can just drag a new view over to the left-most pane. You should probably name one view PortraitView, the other LandscapeView.
For the landscape view, you should set its width and height to be the opposite of PortraitView. i.e., 460 by 320.
Then you can layout buttons, labels, etc on this new landscape view. You need also to connect up the appropriate actions and outlets.
Each view should have its own declaration in the View Controller .h file:
```
IBOutlet UIView *landscape;
IBOutlet UIView *portrait;
```
You should also have corresponding, @property's and as well as @synthesize in the implementation file.

Finally, in your willAnimateSecondHalfOfRotationFromInterfaceOrientation method you want to have lines like:

if(toOrientation == UIInterfaceOrientationPortrait) 
{
   self.view = self.portrait; //selects which view

   //next two lines set up rotation need
   self.view.transform = CGAffineTransformIdentity; 
   self.view.transform = CGAffineTransformMakeRotation(degreesToRadian(0));

   // this is rect view should live in 
   self.view.bounds = CGRectMake(0.0, 0.0, 320.0, 460.0); 
     
} 
else if (toOrientation == UIInterfaceOrientationLandscapeLeft) 
{
   self.view = self.landscape;
   self.view.transform = CGAffineTransformIdentity;
   self.view.transform = CGAffineTransformMakeRotation(degreesToRadian(-90));
   self.view.bounds = CGRectMake(0.0, 0.0, 460, 320);
		
}
// similar code for the other two orientations;
// degreesToRadian is #define degreesToRadian(x) (M_PI *(x)/180.0)

You want to make sure each component uses frame as the layout for switching between view to work correctly in this case.

Logging

For diagnostic/debugging purposes, it is often useful to get your app to write log messages while it is running.
On a Mac, these messages often appear in your console (look in App > Utilities).
In XCode you can see your device's console by looking at: Run > Console or hitting Shift Command R.
To write a log message, you simply call the function NSLog:
```
   NSLog(@"Hello world of logging");
```
Notice this is a C (not Objective-C) function call.

Starting Data Persistence

So far we have considered Views and Controllers in the MVC pattern.
We'd next like look at Models to some extent.
i.e., we'd like some means to store application data persistently between invocations of our program.
To understand how this we will, we first must understand how data is arranged on the iPhone.
Essentially, we have a folder structure just like on a Mac.
Just as on a Mac there is a User folder and within it we have the following sub-folders: tmp, Root, Media, Library, Applications
You can see this folder structure for the simulator by going to: ~/Library/Application Support/iPhoneSimulator/User/
Each iPhone App is stored in the Applications folder. Each of these App folders has in turn a Documents, Library, and tmp.
Next day, we will discuss how our app can access these.

Signing Apps, Auto-Rotations, Logging, Start Data Persistence

Outline