Finish Android Demo

On Monday, we showed a trivial iPhone app.
We started talking about how to use the Android tools in Eclipse to make a trivial Android project.
We showed how to create a new Android Virtual Device.
We can then build and run our trivial application and have it launch on this emulator. The result looks like:

The Basics of an Objective-C Program

For our second iPhone program we are going to actually write code rather than just use Interface Builder.
This code will be in Objective-C so we are going to go over the Basics of Objective-C.
Objective-C can be compiled from the command-line in any environment in you have gcc. We will first look at such a program then work our way back to the iPhone.
Header Files use the extension .h
Implementations use the extension .m (named for mplementation)

A .h file typically might be used to define an interface of a class. This might have the format:


@interface classname : superclassname {
   int my_field; 
    // instance variables can be any C type or  the generic id type.
}
+classMethod1; // + means class method; - means instance method
+(return_type)classMethod2;
+(return_type)classMethod3:(param1_type)parameter_varName;
-(return_type)instanceMethod1:(param1_type)param1_varName :(param2_type)param2_varName;
-(return_type)instanceMethod2WithParameter: (param1_type)param1_varName andOtherParameter:(param2_type)param2_varName;
@end

Implementation Files

To implement the functions you use an implementation file and the syntax:

@implementation classname
+classMethod {
    // implementation
}
-instanceMethod {
    // implementation
}
@end

Invoking Methods

A call obj.method(parameter); in C++ might look like [obj method:parameter]; in Objective-C.

You can have multiple parameters:

[obj method:parameter1 paramName2: parameter2]

To instantiate a class you can send either the new message or instantiate in two steps:
```
    MyObject * o = [MyObject new];
    MyObject * o = [[MyObject alloc] init];
```
You can override the init method of your class to make a new constructor.
The second way is preferred. We first allocate memory for our object; then send it an init message.
Rather than just init we might create a method that takes arguments and inits, in which case the second approach is more flexible.

Example Objective-C Program

// Interface File
#import <objc/Object.h>

@interface MyHello : Object {
   int myNumber;
}
-setNumber:(int)aNumber;
-sayHello;

@end

Example Program cont'd

// implementation file
#import <stdio.h>
#import "MyHello.h" 
@implementation MyHello
-setNumber:(int)aNumber {    myNumber = aNumber;
} 
-sayHello{    
   printf("Hello! %d\n", myNumber);
} 
-(id) init { //self is like this in Java
    self = [super init];
    if (self) { myNumber = 0; }
    return self;}  
@end

Objective-C Example Last Part.

#import "MyHello.h"
int main(void){
MyHello *hello = [MyHello new];  
[hello setNumber:10]; 
   //set the number to echo
[hello sayHello];
return 0;
}
/* To compile in gcc could type:
gcc -arch i386 -x objective-c -Wno-import main.m MyHello.m -lobjc  

To get this to work on 64 bit architecture need to switch to NSObject...
You can actually build XCode projects from the command line:
/Developer/usr/bin/xcodebuild -target project
*/

Objectice-C Types, Foundation Kit

Objective-C was defined before C had a boolean type.
To do booleans in Objective-C you declare a variable to be of type BOOL. This has two values: YES or NO.
We set object pointers to nil rather than NULL, if we haven't declared an object or what to make sure we don't have garbage.
In the Cocoa Touch we will generally have our objects extend at least NSObject which is in the header Foundation/NSObject.h
To get this we will generally import the header Foundation/Foundation.h of the Foundation kit, which also has several other useful classes:
- NSInt - wrapper for an int
- NSString, NSMutableString -- which have a large range of functions for manipulating strings, especially in Unicode.
- NSArray, NSMutableArray -- for arrays
- NSSet, NSMutableSet -- for undordered sets of items
More information about these classes can be found by looking at Help > Documentation and clicking on the Foundation bookmark in XCode.

Reference Counting

In C, we do dynamic memory management with malloc and free.
In Objective-C, a system of reference counting is used.
We already know alloc can be used to allocate memory for our object.

To free up memory associated with our object we should create a dealloc implementation:

-(void)dealloc
{
 /* call release on instance variable; then... */
 [super dealloc];
}

We will almost never directly call dealloc, except as in [super dealloc]...

Instead, we will use the messages retain and release..

[myObj retain]; //increases myObj's reference count by 1.
[myObj release]; // decreases myObj's reference count by 1.

When an object is initially allocated its reference count is set to 1.
If an object's reference count goes to 0, the runtime system will call dealloc for you.
You can determine the current reference count by calling: [myObj retainCount];

Starting a Second Project

Let's now create a second view-based iPhone app and take a look at some of code files...
Our second application is going to have two buttons which control the content of a label on the screen
iPhone projects often use the MVC (Model View Controller) design pattern.
This pattern makes use of three types of classes:
- Model: The classes that hold your application's data
- View: Made up of window, widgets, etc that the user can see and interact with
- Controller: Binds the models and views together and has the application logic that decides how to handle the user's input.

A Second Project

If we look in the Group & Files pane at the controller class created for us, it might look like:

//
//  SecondProjectViewController.h
//  SecondProject
//
//  Created by Chris Pollett on 8/26/09.
//  Copyright San Jose State University 2009. All rights reserved.
//

#import <UIKit/UIKit.h>

@interface SecondProjectViewController : UIViewController {

}

@end

UIViewController is a generic controller class that is part of UIKit.
We can use Interface Builder to layout our two buttons and our label; we will use this class to implement the control for the buttons.
Our controller can refer to objects in the nib file using an instance variable called an outlet.
For example, to control the text label, we might declare an outlet and point it at the label object.
In the opposite direction, interface objects in our nib file can be set to trigger special methods in our controller class.
These special methods are called action methods.

Declaring Actions and Interfaces in Our Header

To declare an action and interface we might do:

#import <UIKit/UIKit.h>

@interface SecondProjectViewController : UIViewController {
   IBOutlet UILabel *statusText;
}
@property (retain, nonatomic) UILabel *statusText;

-(IBAction) buttonPressed:(id)sender;

@end

Let me just say that the @property declaration is a shorthand... It tells the compiler we want to make an assessor (getter) and mutator (setter) method for statusText. i.e., we want to create a method -(id) statusText to get this instance variable; and a method -(void) setStatusText: (id) aStatusText to set it.

You often refer to properties using dot notation in Objective-C. i.e.,

  UILabel *tmp = myController.statusText;
  muController.statusText = someLabel;

Objective-C - Starting Our Second iPhone App

Outline