Az iPhone (és persze a Touch) készülékek multi touch-osak, ez azt jelenti, hogy egyszerre több érintési pontot is le tudnak kezelni.
Legtöbbször elég csak az első érintéssel foglalkoznunk, most így is fogom bemutatni, viszont a minta kódrészletek alapján egyszerű lesz átírni a multi funkcióra.

Alapvetően három fontos esemény van, amivel érdemes foglalkozni:
touchesBegan: az érintés kezdete
Ez az esemény akkor következik be, amikor hozzáérünk a kijelzőhöz.
touchesMoved: a képernyőn az ujjunk mozgása
Ez egy folyamatosan frissülő esemény, amikor a képernyőn mozgatjuk az ujjunkat.
(Itt érdemes meggondolni, hogy milyen mintavételezéssel futtatjuk a touchesMoved-ban elhelyezett kódot, illetve hogy minél rövidebb kódot használjunk!)
touchesEnded: az érintés vége
Ez az esemény akkor következik be, ha elengedjük a kijelzőt.
Ha csak egy pillanatra rábökünk a kijelzőre, akkor is a touchesBegan után ez az esemény mindig bekövetkezik!
(Én azt tapasztaltam, hogy ha rá kell kattintani valamire és nem sikerül elsőre eltalálni, akkor az emberek többsége a ujj mozgtásával megkeresik a megfelelő pontot és ott engedik el a kijelzőt, ezért érdemes itt feldolgozni minden olyan eseményt, ami csak egy egyszerű kattintásnak felel meg!)

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
  NSSet *allTouches = [event allTouches]; // az összes érintés egy tömbben
  UITouch *touch = [[allTouches allObjects] objectAtIndex:0]; // az első érintés
  CGPoint p = [touch locationInView:[self view]]; // az érintés koordinátái
  NSLog(@"A kezdeti koordináták: %f, %f ", p.x, p.y);
}

- (void)touchesMoved:(NSSet *)touches withEvent:(UIEvent *)event {
  NSSet *allTouches = [event allTouches]; // az összes érintés egy tömbben
  UITouch *touch = [[allTouches allObjects] objectAtIndex:0]; // az első érintés
  CGPoint p = [touch locationInView:[self view]]; // az érintés koordinátái
  NSLog(@"Mozgás közben az aktuális koordináták: %f, %f ", p.x, p.y);
}

- (void)touchesEnded:(NSSet *)touches withEvent:(UIEvent *)event {
  NSSet *allTouches = [event allTouches]; // az összes érintés egy tömbben
  UITouch *touch = [[allTouches allObjects] objectAtIndex:0]; // az első érintés
  CGPoint p = [touch locationInView:[self view]]; // az érintés koordinátái
  NSLog(@"Itt engedtem el a kijelzőt: %f, %f ", p.x, p.y);
}

2. Kép mentése (A kódot UIView-ban kell elhelyezni!)

Második AppStore-os programom az iPaint volt, amiben a megrajzolt képet ki lehet menteni a kamera albumba.
A kimetés elég egyszerű, csak arra kell vigyázni, hogy a képet mentés előtt el kell forgatni, mert különben a bitmap fejjel lefelé fog bekerülni az albumba!
Itt egy kicsit átírt kivonat az iPaint-ből, szerintem a kommentek elég beszédesek:

- (void)drawRect:(CGRect)rect {
	CGFloat _Color[4] = { 255,0,0,1 }; // piros szín
	CGMutablePathRef path = CGPathCreateMutable(); // ebben a path-ban tároljuk a megjelenítendő vonalakat, pontokat
	CGContextRef context = UIGraphicsGetCurrentContext(); // az aktuális rajz felület lekérdezése (alap esetben teljes képernyő)
 
	// kép elforgatása, hogy a camera roll-ban jó legyen
	// ezt akkor kell megtenni, ha lementjuk a képet, különben egy if-et tegyünk elé és ne forgassuk, mert a kijelzőn is megfordul!
	CGContextTranslateCTM(context, 0, self.bounds.size.height);
	CGContextScaleCTM(context, 1.0, -1.0);	
 
	// felveszünk egy 3 pixel vastagságú piros vonalat
	CGContextSetLineWidth(context, 3.0);
	CGContextSetStrokeColor(context, _Color);
	CGPathMoveToPoint(path, nil, 5.0, 5.0);
	CGPathAddLineToPoint(path, nil, 100.0, 100.0);
	CGContextAddPath(context, path);
	// kirajzoljuk a képernyőre a path tartalmát (most a piros vonal van benne)
	CGContextStrokePath(context);
 
	// elmentjük a képet
	UIGraphicsBeginImageContext(self.bounds.size);
	CGImageRef vImageRef = CGBitmapContextCreateImage(context);
	CGContextDrawImage(UIGraphicsGetCurrentContext(), self.bounds, vImageRef);
	UIImage *activeImage = UIGraphicsGetImageFromCurrentImageContext();
	UIGraphicsEndImageContext();
	// a saveEnded saját függvény, a mentés végén meghívjuk
	UIImageWriteToSavedPhotosAlbum(activeImage, self, @selector(saveEnded:didFinishSavingWithError: contextInfo:) , nil);
 
	CGContextFlush(context);
}
 
-(void)saveEnded:(UIImage *)image didFinishSavingWithError:(NSError *)error contextInfo:(void *)contextInfo; {
	// Ez akkor fut le, ha a mentés véget ért.
	// Az error-ban megkapjuk, ha valami hiba történt.
	// Itt érdemes értesíteni a felhasználót, hogy vége a mentésnek és itt érdemes törölni a képernyőt is!
}

Legközelebb a Shake, a Status Bar és a levél küldése lesz a téma!

Az AppStore-ban megjelent alkalmazásaim alapján összeírtam néhány hasznos kódrészletet, amelyek mindig jól jöhetnek a fejlesztések során. Ezek az írások nem tutoriálok, inkább nevezném őket segédletnek.

Kezdjük az iTinker-rel. Ez egy vízmérték, ami a beépített accelerometer-t használja és a visszakapott értékek alapján két UIImageView objektumot mozgat. A tetején van egy kis reklám csík, ahol a szöveget mozgatom. Amiről most szó lesz, az az Accelerometer  használata, valamint az UIImageView létrehozása kódból és annak mozgatása.

A kódokhoz egy új View-based application template projectet hoztam létre szifon névvel. Az interface buildert ebben a leírásban nem használom, az objektumokat a példák során kódbol hozom létre.

Először is, hogy legyen mit mozgatnunk, létrehozunk egy kis zöld négyzetet a képernyő közepén. Én most a legegyszerűbb módon veszem fel az ehhez kellő UIImageView-t, természetesen lehet másképp is, sokkal szebben, de most nem ez a téma.

Szóval a szifonViewControllet.m -ben az implementation után vegyünk fel egy UIImageViewt:

szifonViewController.m:

@implementation szifonViewController
 
UIImageView *szifonImageView;
 
- (void)viewDidLoad {

És hogy ne felejtsük el később a memóriát felszabadítani, rögtön hívjuk is meg a release-t a dealloc-ban:

szifonViewController.m:

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

Most már megvan minden ahhoz, hogy a kis négyzetünket megjelenítsük:

szifonViewController.m:

- (void)viewDidLoad {
    szifonImageView = [[UIImageView alloc] init]; // inicializáljuk az ImageView-nkat
    [szifonImageView setFrame:CGRectMake(150.0, 220.0, 20.0, 20.0)]; // képernyő közepére az x=150, y=220 pixelre kiteszünk egy 20x20-as négyzetet
    [szifonImageView setBackgroundColor:[UIColor greenColor]]; // beállítjuk a négyzet hátterét zöldre
    [self.view addSubview:szifonImageView]; // megjelenítjük az aktuális View-n
}

Létrehoztuk a négyzetet, most kezdjük el mozgatni!

Az accelerometer használatához szükségünk van az UIAccelerometerDelegate-re, hogy az alkalmazásunk megkapja a készülék mozgatásakor az elmozdulás mértékét.

Ehhez a ViewController headerjében az interface definícióját módosítanunk kell az alábbiak szerint:

szifonViewController.h:

@interface szifonViewController : UIViewController  {
}

majd hozzá kell adnunk a delegálás elcsípéséhez a következőt:

szifonViewController.h:

- (void)accelerometer:(UIAccelerometer *)accelerometer didAccelerate:(UIAcceleration *)acceleration;

Be kell állítanunk az accelerometer delegálásának a tulajdonságait:

szifonViewController.m -ben a ViewDidLoad-ban a négyzet megjelenítése után szúrjuk be ezt a két sort:

[[UIAccelerometer sharedAccelerometer] setUpdateInterval:0.1]; // 100ms-enként jön az adat, hogy mi az elmozdulás értéke
[[UIAccelerometer sharedAccelerometer] setDelegate:self]; // ezzel indítjuk a delegálást

Most már kapjuk az értékeket, már csak fel kell dolgoznunk azokat és mozgatni a négyzetünket.

szifonViewController.m:

- (void)accelerometer:(UIAccelerometer *)accelerometer didAccelerate:(UIAcceleration *)acceleration {
    // az x, y, z értékeket az accelereometer objektum tartalmazza
    // mi most csak az x és y-al foglalkozunk
    // Mivel az érték -1 és +1 között változik, az elmozdításhoz 20-as szorzót használtam,
    // ez azt jelenti, hogy legkisebb elmozdulás 2 pixel, a legnagyobb 20 pixel, attól függ, mennyire döntjük meg a készülékünket
 
    szifonImageView.center = CGPointMake(szifonImageView.center.x, szifonImageView.center.y - (acceleration.y * 20)); // az y elmozdulás alapján mozgatjuk a négyzetet
    szifonImageView.center = CGPointMake(szifonImageView.center.x + (acceleration.x * 20), szifonImageView.center.y); // az x elmozdulás alapján mozgatjuk a négyzetet
 
    // ez itt néhány ellenőrzés, hogy ne tudjon eltűnni a négyzetünk a kijelzőről; ha nagyon le akarna mászni, egyszerűen visszatesszük a szélére
    if (szifonImageView.center.x < 0) szifonImageView.center = CGPointMake(0.0, szifonImageView.center.y); if (szifonImageView.center.x > 320) szifonImageView.center = CGPointMake(300.0, szifonImageView.center.y);
    if (szifonImageView.center.y < 0) szifonImageView.center = CGPointMake(szifonImageView.center.x, 0.0); if (szifonImageView.center.y > 480) szifonImageView.center = CGPointMake(szifonImageView.center.x, 460.0);
}

Ha mindnet jól csináltunk, a zöld négyzet a készülékünk mozgatásával mozogni fog a kijelzőn.

Összefoglalva a teljes kód:

szifonViewController.h:

1
2
3
4
5
6
7
8

#import <UIKit/UIKit.h>
 
@interface szifonViewController : UIViewController  {
}
 
- (void)accelerometer:(UIAccelerometer *)accelerometer didAccelerate:(UIAcceleration *)acceleration;
 
@end

szifonViewController.m:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#import "szifonViewController.h"
 
@implementation szifonViewController
UIImageView *szifonImageView;
 
- (void)viewDidLoad {
    szifonImageView = [[UIImageView alloc] init]; // inicializáljuk az ImageView-nkat
    [szifonImageView setFrame:CGRectMake(150.0, 220.0, 20.0, 20.0)]; // képernyő közepére az x=150, y=220 pixelre kiteszünk egy 20x20-as négyzetet
    [szifonImageView setBackgroundColor:[UIColor greenColor]]; // beállítjuk a négyzet hátterét zöldre
    [self.view addSubview:szifonImageView]; // megjelenítjük az aktuális View-n
    [[UIAccelerometer sharedAccelerometer] setUpdateInterval:0.1]; // 100ms-enként jön az adat, hogy mi az elmozdulás értéke
    [[UIAccelerometer sharedAccelerometer] setDelegate:self]; // ezzel indítjuk a delegálást
    [super viewDidLoad];
}
 
- (void)accelerometer:(UIAccelerometer *)accelerometer didAccelerate:(UIAcceleration *)acceleration {
    // az x, y, z értékeket az accelereometer objektum tartalmazza
    // mi most csak az x és y-al foglalkozunk
    // Mivel az érték -1 és +1 között változik, az elmozdításhoz 20-as szorzót használtam,
    // ez azt jelenti, hogy legkisebb elmozdulás 2 pixel, a legnagyobb 20 pixel, attól függ, mennyire döntjük meg a készülékünket
    szifonImageView.center = CGPointMake(szifonImageView.center.x, szifonImageView.center.y - (acceleration.y * 20)); // az y elmozdulás alapján mozgatjuk a négyzetet
    szifonImageView.center = CGPointMake(szifonImageView.center.x + (acceleration.x * 20), szifonImageView.center.y); // az x elmozdulás alapján mozgatjuk a négyzetet
    // ez itt néhány ellenőrzés, hogy ne tudjon eltűnni a négyzetünk a kijelzőről; ha nagyon le akarna mászni, egyszerűen visszatesszük a szélére
    if (szifonImageView.center.x < 0) szifonImageView.center = CGPointMake(0.0, szifonImageView.center.y); if (szifonImageView.center.x > 320) szifonImageView.center = CGPointMake(300.0, szifonImageView.center.y);
    if (szifonImageView.center.y < 0) szifonImageView.center = CGPointMake(szifonImageView.center.x, 0.0); if (szifonImageView.center.y > 480) szifonImageView.center = CGPointMake(szifonImageView.center.x, 460.0);
}
 
- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
}
 
- (void)viewDidUnload {
}
 
- (void)dealloc {
    [szifonImageView release];
    [super dealloc];
}
 
@end

Ha mindent jól csináltál, ilyen lesz az eredmény: