Outline

• Auto-Rotations
• Logging
• Data Persistence

We'll cover these first for iPhone then in the second half of the lecture talk about Android.

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 a new View Based application, in the View Controller generated for your project there should appear auto-magically 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.

Screenshots of an Awkward-for-Landscape Portrait Layout, before and After Tweaking

Finer Grain Control

• Notice in the last image the buttons are still two across, three down.
• This uses the screen resources somewhat inefficiently.
• To improve this, let's first create outlets and properties for each of our buttons and hook these up...

  #import <UIKit/UIKit.h>
  
  @interface RotateExampleViewController : UIViewController {
  
  	IBOutlet UIButton *button1;
  	IBOutlet UIButton *button2;
  	IBOutlet UIButton *button3;
  	IBOutlet UIButton *button4;
  	IBOutlet UIButton *button5;
  	IBOutlet UIButton *button6;
  }
  @property (nonatomic, retain) UIButton *button1;
  @property (nonatomic, retain) UIButton *button2;
  @property (nonatomic, retain) UIButton *button3;
  @property (nonatomic, retain) UIButton *button4;
  @property (nonatomic, retain) UIButton *button5;
  @property (nonatomic, retain) UIButton *button6;
  
  @end
  

Finer Grain Control

• Next we override the following method to put things where we ant after the rotation:

  @synthesize button1;
  @synthesize button2;
  @synthesize button3;
  @synthesize button4;
  @synthesize button5;
  @synthesize button6;
  
  -(void)willAnimateSecondHalfOfRotationToInterfaceOrientation: 
  (UIInterfaceOrientation)fromInterfaceOrientation
  duration:(NSTimeInterval)duration {
  	UIInterfaceOrientation toOrientation = self.interfaceOrientation;
  	
  	[UIView beginAnimations:@"move my buttons" context:nil];
  	//says we'd like the switch animated; give animation block a name
  	
  	if(toOrientation == UIInterfaceOrientationPortrait || 
  	   toOrientation == UIInterfaceOrientationPortraitUpsideDown) {
  		button1.frame = CGRectMake(20, 20, 125, 125);
  		button2.frame = CGRectMake(175, 20, 125, 125);
  		button3.frame = CGRectMake(20, 168, 125, 125);
  		button4.frame = CGRectMake(175, 168, 125, 125);
  		button5.frame = CGRectMake(20, 315, 125, 125);
  		button6.frame = CGRectMake(175, 315, 125, 125);
  	} else {
  		button1.frame = CGRectMake(20, 20, 125, 125);
  		button2.frame = CGRectMake(20, 155, 125, 125);
  		button3.frame = CGRectMake(177, 20, 125, 125);
  		button4.frame = CGRectMake(177, 155, 125, 125);
  		button5.frame = CGRectMake(328, 20, 125, 125);
  		button6.frame = CGRectMake(328, 155, 125, 125);
  		
  	}
  	
  	[UIView commitAnimations];
  	// our animation clock is finished
  	
  }
  - (void)dealloc {
  	[button1 release];
  	[button2 release];
  	[button3 release];
  	[button4 release];
  	[button5 release];
  	[button6 release];
      [super dealloc];
  }
     
  

Some Comments on Using Two Views

• A second way to do auto-rotation is to use two views. One for portrait one for landscape and switch between them.
• 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., 480 by 300 (you can get this, by clicking on the rotate icon in the bar of the view in IB).
• 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;
  

• In the header we'll make use of a define:

  #define degreesToRandians(x) (M_PI * (x)/180.0)
  

• If you want to hook-up buttons etc, if both views had a Button 1, then you should have an outlet for say button1Portrait, button1Landscape
• You should also have corresponding, @property's and as well as @synthesize in the implementation file.
• Finally, we override willAnimateFirstHalfOfRotationFromInterfaceOrientation method this time:

  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;
  

• 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.

Handling Rotations in Android

• We can change between Portrait or Landscape mode using CTRL-F12 in the emulator.
• We've already seen that we can switch between two views in Android by calling the Activities: setContentView(R.layout.nameOfLayout) method.
• So if we want our app to look good in both Portrait and Landscape orientation we could create two views -- one for each orientation.
• This just leaves the problem of getting some code to run, when the orientation changes.
• When the orientation changes, recall the system goes through the process of saving instance state, pausing, stopping and destroying, then creating a new instance of the activity.
• So we can just check for the orientation change in onCreate.

Handling Rotations in Android - cont'd

• So we merely have to override this method with our code:

      public void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          if(getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) 
          {
          	 setContentView(R.layout.main_portrait);
          }
          else
          {
         	     setContentView(R.layout.main_landscape);       	
          }
      //other code of onCreate
      }
  

• Alternatively, one could try to override the onConfigurationChanged(Configuration) method of Activity. However, for this to work we'd need to also change the AndroidManifest file's <activity>'s android:configChanges attribute ORing (take the | of the different config properties you want to be notified on) in orientation.

Logging

• As with the iPhone, Android supports logging events.
• To use logging you need to import android.util.Log .
• To see a list of log messages one can use LogCat by going to Window > Show View > Other... > Android > LogCat .
• There are several types of log messages you can write:
  • Log.e(): Errors
  • Log.w(): Warnings
  • Log.i(): Information
  • Log.d(): Debugging
  • Log.v(): Verbose

Logging Example

• Each of these logging methods takes either two or three arguments. The first is the tag, which is usually String name of the Activity; the second parameter is the message you want. If there is a third parameter it is a Throwable object which might be caught be some enclosing code.

  Log.i("Hw1", "Main ViewCreated");

  
  

Storing and Retrieving Data

• Like the iPhone, Android has a mechanism for storing application information persistently.
• The three main ways to do this are: using a SharedPreferences object, through the Android filesystem, or using SQLite.
• We will look at each of these in turn.

Using Preferences

• You access a android.content.SharedPreferences object through the Context you are working in.
• Many Android classes have a reference to, or themselves extend from Context.
• For example, both Activity and Service extend Context.
• A Context object includes a getSharedPreferences(String prefname, int accessmode); method.
• prefname will correspond to a file prefname.xml that is stored in /data/data/PACKAGE_NAME/shared_prefs in the Android phone's filesystem.
• accessmode - corresponds to one a list of predefined static constants in Content. This in turn corresponds to Unix filesystem modes: Context.MODE_WORLD_READABLE, Context.MODE_WORLD_WRITEABLE, etc. You can OR these together using +.
• If you want to browse the emulator's filesystem one can, in Eclipse, go to: Window > Show View > Other... > Android > File Explorer.

More on Using Preferences

• You typically would write preferences, either when the activity starts in onCreate, or when you are just about to switch activities.
• Here is an example of some code to open a SharedPreferences and write to it:

  SharedPreferences myPref = getSharedPreferences("MY_APP_PREFS", 
     Context.MODE_WORLD_WRITEABLE + Context.MODE_WORLD_READABLE);
  
  Log.i("My_Activity", 
     "Old Some_Key" + myPref.getString("Some_Key","Key did not exist") );
  //second arg is returned if key did not exist
  
  Editor myPrefEditor = myPref.edit();
  myPrefEditor.putString("Some_Key", "Some Value");
  myPrefEditor.commit();