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 SecondPhone2012ViewController : UIViewController
@property (weak, nonatomic) IBOutlet UIButton *button1;
@property (weak, nonatomic) IBOutlet UIButton *button2;
@property (weak, nonatomic) IBOutlet UIButton *button3;
@property (weak, nonatomic) IBOutlet UIButton *button4;
@property (weak, nonatomic) IBOutlet UIButton *button5;
@property (weak, nonatomic) IBOutlet UIButton *button6;
@end

Notice this time we created the project with automatic reference counting, so we see weak rather than retain above.
A weak reference roughly means, we have a reference to an object but we don't intend ownership of it. i.e., someone else has retained the object and is responsible for releasing the object.

Finer Grain Control

Next we override the following method to put things where we want after the rotation:
In viewDidLoad we add code to make the buttons the way we want when we initially load the page.

@synthesize button1;
@synthesize button2;
@synthesize button3;
@synthesize button4;
@synthesize button5;
@synthesize button6;

- (void)viewDidLoad
{
    [super viewDidLoad];
	// Do any additional setup after loading the view, typically from a nib.
    
    [self willAnimateRotationToInterfaceOrientation: self.interfaceOrientation duration:0];
}

-(void)willAnimateRotationToInterfaceOrientation: 
(UIInterfaceOrientation)interfaceOrientation
duration:(NSTimeInterval)duration {
	
	if(UIInterfaceOrientationIsPortrait(interfaceOrientation)) {
		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);
		
	}
	
}

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 copy and paste the existing view.
Then for the new view make its orientation landscape under attribute inspector.
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 ViewController.h file (made by ctrl-dragging in assistant view):

//note strong as the controller DOES own them
@property (strong, nonatomic) IBOutlet UIView *portrait; 
@property (strong, nonatomic) IBOutlet UIView *landscape;

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

#define degreesToRadians(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 willAnimateRotationToInterfaceOrientation 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.

Quiz

Which of the following is true?

In HTML 5 Javascript, a rotateorientation event is generated when the user changes the device from portrait to landscape mode.
shouldAutorotateToInterfaceOrientation is called by iOS to determine which orientation your app supports.
Javascript uses the class keyword to declare a new class.

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: View > Navigators > Log Navigator in XCode or hitting Shift Command C.
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 works, 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();

Screen Orientation, Logging, Persistence

Outline

Finer Grain Control

Finer Grain Control

Some Comments on Using Two Views

Quiz

Logging

Starting Data Persistence

Handling Rotations in Android

Handling Rotations in Android - cont'd

Logging

Logging Example

Storing and Retrieving Data

Using Preferences

More on Using Preferences