Introduction

Last week, we were covering the basics of how Core Graphics and OpenGL work on the iPhone.
Today, we will look at how to handle various kinds of touch events on mobile phones.
First, let's specify some common terms:
- A gesture is any sequence of events that happens from the time you touch the screen with one or more fingers until you lift your fingers off the screen.
- An event is used to encapsulate information about one or more gestures and is generated when a user interacts with the screen.
- A touch refers to a single finger being placed on the screen. The number of touches in a gesture is the number of fingers on the screen at the same time.
- A tap is a gesture in which a single finger is touched to the screen and immediately lifted off without moving the finger around.
You can also register events for multiple taps in quick succession. (double-tap, triple-tap, etc.)

Responder Chain

Gesture get passed through the iPhone OS as events and get passed through the responder chain.
Any class that has UIResponder as a super class is a responder. (For example, all UIView, UIController, UIViewController).
If the first responder for an event doesn't handle a particular event, it passes that event up the responder chain.
A responder can also both partially handle an event and still pass it along the chain, or it can choose to handle it and stop the percolation.
The event chain proceeds up the view hierarchy for view that contained the events coordinates, until finally it reaches UIApplication.
If this does not handle the event, then the event is discarded.

Forwarding Events

Events aren't forwarded by default.
Suppose your view responds to a swipe but not a tap.
However, some enclosing view might respond to a tap.

In order to forward, in your event you might have code like:

-(void)respondToMyEvent: (UIEvent *) event {
   if(condition) {
      [self handleEvent: event];
   } else {
      [self.nextResponder respondToMyEvent: event];
   }
}

Quiz

Which of the following statements is true:

On Phone 7 you can telnet into port 5554 of the emulator and send commands like geo fix -10.5 23.4 to specify GPS info.
SensorManager is one of the classes used to get accelerometer data on Android.
Expression Blend is a common way to make animations on the iPhone.

Multitouch Architecture

You can put your code to handle gestures in either a UIView object or in your UIViewController
Examples of the former are things like UISwitch and UISlider.
A switch might want to turn itself on or off based on a touch.
However, if the gesture being processed affects more than the object being touched one typically puts the code in the view's controller class.

Gesture Notification

There are four methods used to notify a responder about touches and gestures.
When the user first touches the screen, the iPhone looks for a responder that has a method of signature touchesBegan:withEvent.

Code for such a method might look like:

- (void)touchesBegan: (NSSet *)touches withEvent:(UIEvent *)event {
  NSUInteger numTaps = [[touches anyObject] tapCount];
  NSUInteger numTouches = [touches count]; 
}

touches is a set of UITouch's, each represents one finger touching the screen.
If there are more than one numTouches is more than 1 than numtaps == 1 as taps are defined as only involving one finger.
If taps were 2 than it would correspond to a double tap.

More on Gesture Notification

It is often useful to know about those touches which occurred only within the current view.

You could find this out with code like:

NSSet *myTouches = [event touchesForView:self.view];

To find out where a touch occurred, given a UITouch object we can do:
```
CGPoint point = [touch locationInView:self];
```
In addition to static touches one can get notified while a user is moving fingers across the screen by implementing, touchesMoved:withEvent:
This method will actually get called mutliple times during a long drag event, and each time it is called you get another events which you can handle.
UITouch objects also hold the previous location of a touch.

Still More on Gesture Notification

You can find out when a finger is removed from the screen by having the method touchesEnded:withEvent:
Finally, there is also a touchesCancelled:withEvent:
This might be called if a user is touching the screen and it gets interrupted by something like an incoming phone call.

Touch Application

We will now create a simple app to experiment with touch events on the iPhone.
It will display a message saying what kind of touch event has occurred, and it will also say how many touches or taps there were.
The touch events are better demo'd on an actual device than in the simulator.
For this new project we use the View Based App template.

View Controller Header

We then modify the view controller header as follows:

#import <UIKit/UIKit.h>

@interface TouchAppViewController : UIViewController {
	IBOutlet UILabel *messageLabel;
	IBOutlet UILabel *tapsLabel;
	IBOutlet UILabel *touchesLabel;

}

@property (nonatomic, retain) UILabel *messageLabel;
@property (nonatomic, retain) UILabel *tapsLabel;
@property (nonatomic, retain) UILabel *touchesLabel;

-(void)updateLabelsFromTouches: (NSSet *)touches;
@end

Changes to TouchApp XIB file

We next modify the view controller's xib file by adding three labels.
We center the labels and change the text to Messages, Taps, Touches.
We control drag from the File's Owner to each of the labels and either select, the messagesLabel outlet, tapsLabel outlet, or touchesLabel outlet.
Finally, we click on the view in interface builder and click on the View Attributes tab.
We make sure that under the Interaction settings both User Interaction Enabled and Multiple Touch are checked.

View Controller Code

The view controller's code is then set up as follows:

#import "TouchAppViewController.h"

@implementation TouchAppViewController

@synthesize messageLabel;
@synthesize tapsLabel;
@synthesize touchesLabel;

-(void) updateLabelsFromTouches:(NSSet *)touches {
	NSUInteger numTaps = [[touches anyObject] tapCount];
	NSString *tapsMessage = [[NSString alloc]
           initWithFormat:@"%d taps detected", numTaps];
	tapsLabel.text = tapsMessage;
	[tapsMessage release];
	
	NSUInteger numTouches = [touches count];
	NSString *touchMsg = [[NSString alloc] initWithFormat:
           @"%d touches detected", numTouches];
	touchesLabel.text = touchMsg;
	[touchMsg release];
}


- (void)didReceiveMemoryWarning {
	// Releases the view if it doesn't have a superview.
    [super didReceiveMemoryWarning];
	
	// Release any cached data, images, etc that aren't in use.
}

- (void)viewDidUnload {
	// Release any retained subviews of the main view.
	// e.g. self.myOutlet = nil;
}


- (void)dealloc {
	[messageLabel release];
	[tapsLabel release];
	[touchesLabel release];
    [super dealloc];
}

#pragma mark -
- (void) touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
  messageLabel.text = @"Touches Began";
	[self updateLabelsFromTouches:touches];	
}

- (void) touchesCancelled:(NSSet *)touches withEvent:(UIEvent *)event {
	messageLabel.text = @"Touches Cancelled";
	[self updateLabelsFromTouches:touches];	
}

- (void) touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event {
	messageLabel.text = @"Touches Ended";
	[self updateLabelsFromTouches:touches];	
}

- (void) touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event {
	messageLabel.text = @"Drag detected";
	[self updateLabelsFromTouches:touches];	
}

@end

Touch App Screenshot

Screenshot of the touch app running showing a message that a touch event just ended

Handling More Complicated Touch Events

To handle more complicated events on the iPhone such as swipes, pinches, and proper handling of multiple taps we use the basic structure we've already created and make a note of where things happen on the screen.
We say something is a swipe in some direction based on the coordinate where the finger first touched the screen and based on the coordinate on which it was released from the screen.
Similarly, for a pinch we check that two touches were registered on the screen and their starting coordinates are farther apart then their ending coordinates.

To check if something is a double tap, but not a triple tap, you can use methods like:


case 2: //double tap
[NSObject cancelPreviousPerformRequestWithTarget:self
   selector:@selector(singleTap) object:nil];

[self performSelector:@selector(doubleTap) withObject:nil afterDelay: .4]
break;

case 3: //triple tap
[NSObject cancelPreviousPerformRequestWithTarget:self
   selector:@selector(doubleTap) object:nil];

[self performSelector:@selector(tripleTap) withObject:nil afterDelay: .4]
break;

in touchesBegan.

More complicated gestures like making a check-mark on the screen are similarly constructed out of the basic touch events
We conclude our discussion of iPhone Touch Events by giving an example of how to do swipes.

Swipe Example

To begin we create a new view-based application.
This application will display in a label whether a vertical or horizontal swipe was detected.

We modify the boiler-plate view controller header to look like:

#import <UIKit/UIKit.h>

#define kMinimumGestureLength  25
#define kMaximumVariance 5

@interface SwipeAppViewController : UIViewController {
	IBOutlet UILabel *label;
	
	CGPoint gestureStartPoint;
	
}

@property (nonatomic, retain) UILabel *label;
@property CGPoint gestureStartPoint;
-(void)eraseText;
@end

Next we edit the view controller's xib file and add a label and ctrl-click from the File's Owner to the label and connect it to our outlet.

Swipe Controller Code

#import "SwipeAppViewController.h"

@implementation SwipeAppViewController


@synthesize label;
@synthesize gestureStartPoint;

-(void)eraseText {
   label.text = @"";
}


- (void)didReceiveMemoryWarning {
	// Releases the view if it doesn't have a superview.
    [super didReceiveMemoryWarning];
	
	// Release any cached data, images, etc that aren't in use.
}

- (void)viewDidUnload {
	// Release any retained subviews of the main view.
	// e.g. self.myOutlet = nil;
}


- (void)dealloc {
	[label release];
    [super dealloc];
}

#pragma mark -
-(void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
	UITouch *touch = [touches anyObject];
	gestureStartPoint = [touch locationInView:self.view];
}

-(void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event {
	UITouch *touch = [touches anyObject];
	CGPoint currentPosition = [touch locationInView:self.view];
	
	CGFloat deltaX = fabsf(gestureStartPoint.x - currentPosition.x);
	CGFloat deltaY = fabsf(gestureStartPoint.y - currentPosition.y);
	
	if(deltaX >= kMinimumGestureLength && deltaY <= kMaximumVariance) {
		label.text = @"Horizontal swipe detected";
		[self performSelector:@selector(eraseText) withObject:nil afterDelay: 2];
		
	} else 	if(deltaY >= kMinimumGestureLength && deltaX <= kMaximumVariance) {
		label.text = @"Vertical swipe detected";
		[self performSelector:@selector(eraseText) withObject:nil afterDelay: 2];
	}
}

@end

Android Key and Touch Events

We have already seen that in Android we can create a class which implements View.OnClickListener and then set use a View's setOnClickListener method to get this class to handle click events for that view.
Similarly, you can set a View's OnKeyListener with an object of a class implementing View.OnKeyListener to handle KeyEvents.
To implement this interface you have to define a method:
```
boolean onKey(View v, int keyCode, KeyEvent event)
```
the key code tells you what key was pressed.
KeyEvent's have predefined constants for the different keyCode's as well as methods to figure out keyboard state (was shift pressed? etc).
A View also can have a OnTouchListener which is an Object of a class implementing View.OnTouchListener.
To implement this class, you need to implement the method:
```
boolean onTouch(View v, MotionEvent event)
```
MotionEvent has a method getAction() which returns an int from a list of constants which says what kind of touch event it was.
The event actually holds an array of x, y coordinates associated with the event and has member functions getHistoricalX(int i), getHistoricalY(int i), getHistorySize() for accessing these.
The most recent points can be obtained with getX() and getY().

Touch Events

Outline