Wichtig ist natürlich, dass sich auf dem Mac auf dem die nachfolgenden Commands ausgeführt werden, auch wirklich ein Backup befindet…

1. Zip file downloaden und im Home Verzeichnis entpacken
2. Terminal App öffnen
3. Setzen der Dateiattribute: chmod u=x createdb
4. Ausfuhren der Datei mit: ./createdb
5. Fertig!

Anmerkung: Je nach SDK kann es jetzt noch sein, dass man im Finder die Datei /Users/admin/Library/Application Support/iPhone Simulator/User/Library/AddressBook/AddressBook.sqlitedb auch noch in die anderen Verzeichnisse (also z.B. /Users/admin/Library/Application Support/iPhone Simulator/3.1.3/Library/AddressBook/AddressBook.sqlitedb) kopieren muss, was aber wieder im Finder geschehen kann.

Btw.: Das Script habe ich übrigens nicht ganz selber geschrieben, sondern vor einiger Zeit mal irgendwo gefunden und angepasst. Wenn ich den Link wieder finde füge ich ihn noch an.

• Man benutzt den Cover Flow View aus den Private Frameworks von Apple (Keine gute Idee, wenn man die App später auch erfolgreich in den AppStore bringen möchte)
• Man benutzt Core Animation und Layers
• Man verwendet OpenGL

Auf die erste Möglichkeit gehe ich aus verständlichen Gründen nicht weiter ein. Die zweite Variante mit Core Animation kam in einem meiner recht frühen Projekte zum Einsatz (Den Beispielcode erläutere ich nacholgend) und hat sich gut bewährt. Variante 3 setze ich aktuell in den Projekten ein, kann als Library gekauft werden und ist zudem im Video zu sehen.

Da das Core Animation Framework auf dem iPhone nicht ganz so mächtig wie unter MacOSX ist, muss man auf Filter verzichten, trotzdem sind schöne Ergebnisse zu erzielen. Doch nun zum Code.

#import
#import 
 
@protocol RBCoverFlowDelegate
- (int)numberOfItems;
- (UIImage*)coverImageForIndex:(int)index;
- (UIImage*)placeholderImage;
- (void)coverHasChangedToIndex:(int)index;
- (void)clickOnCoverWithIndex:(int)index;
@end
 
@interface RBCoverFlowView : UIView {
	CGPoint _startTouchPosition;
	float _centerPosition;
	float _sidePosition;
	CATransform3D _leftTransform;
	CATransform3D _rightTransform;
 
	CALayer* _contentLayer;
 
	id _delegate;
	int _itemCount;
 
	CGImageRef _placeholderImageRef;
	UIImage* _placeholderImage;
	CGImageRef _maskedPlaceholderImageRef;
 
	CGSize _imageSize;
	CGFloat _imageScaleX;
	CGFloat _imageScaleY;
 
	float _rowScaleFactor;
}
 
// Start the cover flow
- (void)start:(id)delegate;
 
@end

Der Cover Flow besteht zunächst aus einem “Hauptview”, der von UIView abgeleitet ist und in dem die Covers dargestellt werden. Dieser ist zudem für das Verarbeiten der Touches und der gesamten Animation zuständig.

Die Covers selber bestehen aus einzelnen Layern, bzw. genau drei Layern pro Cover. Der Layer mit dem Bild selber, ein Layer, der die Spiegelung (Reflection) darstellt und ein Rahmen-Layer, der das ganze Cover umschliesst.

- (CALayer *)addCoverLayer:(int)index {
	CALayer* containerLayer = [CALayer layer];
	containerLayer.name = [NSString stringWithFormat:@"%d", index];
	containerLayer.frame = CGRectMake(0.0f, 0.0f, [[self maxAvalibleImageWidth] floatValue], 1.5f * [[self maxAvalibleImageHeight] floatValue]);
	containerLayer.contentsGravity = kCAGravityResize;
 
	CALayer* holderLayer = [CALayer layer];
	holderLayer.name = [NSString stringWithFormat:@"Holder_%d", index];
	holderLayer.frame = CGRectMake(0.0f, 0.0f, [[self maxAvalibleImageWidth] floatValue], 1.5 * [[self maxAvalibleImageHeight] floatValue]);
	holderLayer.contentsGravity = kCAGravityResize;
 
	CALayer* imageLayer = [CALayer layer];
	imageLayer.name = [NSString stringWithFormat:@"Image_%d", index];
	imageLayer.contents = (id)_placeholderImageRef;
	imageLayer.frame = [self imageRect:(CGImageRef)imageLayer.contents];
	imageLayer.contentsGravity = kCAGravityResizeAspectFill;
	imageLayer.masksToBounds = YES;
 
	CALayer* reflectionLayer = [CALayer layer];
	reflectionLayer.name = [NSString stringWithFormat:@"Reflection_%d", index];
	reflectionLayer.contents = (id)_maskedPlaceholderImageRef;
	CGRect frame = [self imageRect:(CGImageRef)reflectionLayer.contents];
	frame.origin.y = imageLayer.frame.size.height + 2;
	reflectionLayer.frame = frame;
	reflectionLayer.contentsGravity = kCAGravityResize;
	reflectionLayer.masksToBounds = YES;
	reflectionLayer.transform = CATransform3DMakeScale(1.0f, -1.0f, 1.0f);
	reflectionLayer.opacity = 0.6;
 
	[containerLayer setValue:imageLayer forKey:kImageLayerKey];
	[containerLayer setValue:reflectionLayer forKey:kImageReflectionKey];
	[containerLayer setValue:holderLayer forKey:kImageHolderKey];
 
	[holderLayer addSublayer:imageLayer];
	[holderLayer addSublayer:reflectionLayer];
	[containerLayer addSublayer:holderLayer];
 
	return containerLayer;
}

Sind die Layer erstellt worden, müssen die einzelnen Cover nun entsprechend positioniert werden, damit das Aussehen dem Cover Flow der iPod App entspricht. Dies erreicht man, in dem man jeden einzelnen Layer im Raum positioniert, skaliert und leicht dreht.

- (void)layoutSublayer:(CALayer*)rootLayer number:(int)number {
	int selectedIndex = [[_contentLayer valueForKey:@"selectedIndex"] integerValue];
 
	rootLayer.frame = CGRectMake(0.0f, 0.0f, [[self maxAvalibleImageWidth] floatValue], 1.5f * [[self maxAvalibleImageHeight] floatValue]);
 
	CATransform3D layerTransform = CATransform3DIdentity;
	layerTransform.m34 = 1.0f / _sidePosition;
 
	CALayer* holder = [rootLayer valueForKey:kImageHolderKey];
 
	CGPoint pos = CGPointMake(CGRectGetMidX(_contentLayer.bounds), CGRectGetMidY(_contentLayer.bounds));
 
	if (number < selectedIndex) {
		pos.x -= (selectedIndex - number) * _imageSize.width * _rowScaleFactor;
		holder.transform = _leftTransform;
		holder.zPosition = _sidePosition;
		rootLayer.zPosition = _sidePosition - 0.1f * (selectedIndex - number);
		rootLayer.sublayerTransform = layerTransform;
	} else if (number > selectedIndex) {
		pos.x += (number - selectedIndex) * _imageSize.width * _rowScaleFactor;
		holder.transform = _rightTransform;
		holder.zPosition = _sidePosition;
		rootLayer.zPosition = _sidePosition - 0.1f * (number - selectedIndex);
		rootLayer.sublayerTransform = layerTransform;
	} else {
		pos.x = (self.bounds.size.width - _imageSize.width) / 2;
		holder.transform = CATransform3DIdentity;
		holder.zPosition = _centerPosition;
		holder.filters = nil;
		rootLayer.zPosition = _centerPosition;
		rootLayer.sublayerTransform = CATransform3DIdentity;
	}
 
	rootLayer.position = pos;
}

Die Animation ist in dem Code (Hier sind die kompletten Source Files) bewusst recht einfach gehalten und unterstützt keine sogenannten Heartbeat Animationen, d.h. Animationen die sogleich beginnen, wenn der Finger aufgesetzt wird. Im käuflichen und auf OpenGL basierten Code ist dies selbstverständlich vorhanden und insbesondere das Laden und Aufbauen der Bilder noch stark optimiert. Aber als Einstieg und fürs bessere Verständnis hoffe ich, dass der Beispielcode hier erstmal weiterhilft. Wer mehr darüber erfahren möchte, dem möchte ich nochmals unsere Workshops ans Herz legen, in denen wir wesentlich tiefer in die Materie einsteigen können. Also, viel Spass beim Cover Flow programmieren und nicht vergessen, auf mein Blog zu verlinken wenn Ihr die erste iApp mit Cover Flow in den Appstore bringt

Anfangs basierte dieser Code übrigens auf einem Beispiel Code von Bill Dudney, der damals einen Artikel über die Programmierung eines Cover Flow unter MacOSX veröffenlichte und auch ein sehr gut geschriebenes Buch zum Thema Core Animation geschrieben hat.

Wichtigstes Element: Die Klasse

@interface Person : NSObject {
     // Das sind Instanz Variablen
     int alter;  // ... vom Typ int
     NSString* name;  // ...vom Typ NSString (Klasse)
     NSString* vorname;
}
 
// Das sind Messages:
// In Objective-C heissen Methoden Messages
- (void)initialisieren;
- (void)setAlter:(int)alter;
- (void)setPerson:(NSString*)name vorname:(NSString*)vorname;
- (int)getJahrgang;
 
@end
 
@implementation Person
 
- (void)setAlter:(int)alter {
    // Mach irgendetwas ...
}
 
...
 
@end

Darin unterscheidet sich die Sprache noch nicht wesentlich von vielen Anderen, wie z.B. Java oder C#. Wie in C++ trennt man allerdings Klassen in deren Beschreibung (@interface) und deren Implementierung (@implementation).

Universeller Zugriff auf Klassen: id
Der Datentyp id ist eine einfache, aber wichtige Erweiterung in Objective-C. Um Klassen unabhägig vom Typ (Bsp. Person) ansprechen zu können, genügt es diese mit id zu deklarieren. Dies wird insbesondere bei der Kommunikation zwischen Interface Builder und Code (Messaging) intensiv genutzt.

id person = [Person new];

Der Aufruf von Klassen: Messages
Ein wenig ungewohnt sieht das Ganze aus, wenn man eine Nachricht (Message) einer Klasse aufrufen möchte. Obige Klasse wird beispielsweise wie folgt angesprochen:

Person* person = [Person new];
[person initialisieren];

und mit Parametern:

Person* person = [Person new];
[person setAlter:35];
[person setPerson:@"Muster" vorname:@"Peter"];

Vereinfachung durch Properties (@property)
Properties gibt es seit Version 2.0 von Objective-C und erweitern Klassen um die Möglichkeit, einfacher auf Instanz Variablen zuzugreifen. Eine Fähigkeit, die es eigentlich in allen modernen objektorientieren Sprachen gibt. Damit kann der Codeumfang stark reduziert werden, da der Compiler selber das mühsame Schreiben der Getter und Setter Methoden übernimmt:

@interface Person : NSObject {
     int alter;
     NSString* name;
     NSString* vorname;
}
 
@property int alter;
@property (nonatomic, retain) NSString* name;
@property (nonatomic, retain) NSString* vorname;
 
@end
 
@implementation Person
 
@synthesize alter;
@synthesize name;
@synthesize vorname;

Wobei die Vereinfachung genaugenommen erst beim Aufruf zum Tragen kommt, da nun folgendermassen auf die Instanz Variablen des Objekts zugegriffen werden kann:

Person* person = [Person new];
person.alter = 35;
person.name = @"Muster";
person.vorname = @"Peter";
int jahrgang = 2009-person.alter;

Die sieht natürlich vorallem für Entwickler, die von Java oder C# her kommen, sehr viel gewohnter aus und bietet zudem einige Vorteile bei der Speicherverwaltung. Wer sich noch näher mit Properties beschäftigen möchte, der findet auf den Apple Seiten alles Wichtige dazu, auch was es mit dem Keyword @synthesize und den Attributen nonatomic und retain auf sich hat.

There’s one more thing: IBOutlet und IBAction
Die beiden Keywords IBOutlet und IBAction gehören genaugenommen nicht zu Objective-C und dienen dazu, den Code für den Interface Builder zu markieren. So kann dieser erkennen, welche Message durch welches UI Element (Bsp. Button) aufgerufen werden soll (Action Target Prinzip) und welche Instanz Variable mit welchem UI Element (Bsp. Label) verknüpft wird. Die Anwendung ist dabei ganz einfach:

@interface Person : NSObject {
     UILabel* text;
}
 
// Dieses Textfeld kann in Interface Builder verknüpft werden
@property (nonatomic, retain) IBOutlet UILabel* text;
 
// Diese Message kann von Interface Builder aufgerufen werden
- (IBAction)aendereText:(id)sender;
 
@end

So, das soll es nun aber für den Moment auch schon sein, obwohl die Sprache natürlich noch viel mehr zu bieten hat. Für den Einstieg und erste einfache Programme genügt dies aber bereits udn wir werden dies in den kommenden Screencasts auch intensiv nutzen.
Also, nur Mut! Der Einstieg ist ein wenig ungewohnt, aber man findet sich schnell zurecht und Spass macht es sowieso.

Und hier wie gewohnt, der Source Code dazu. Viel Spass beim Auspropieren!

Soweit unser Einstig in MapKit. Im nächsten Beitrag bauen wir das Programm aus und ergänzen es um eine einfache Suche nach Orten, die wir anschliessend in der Karte anzeigen.
Source zum Artikel

1
2

sudo ipfw pipe 1 config bw 120Kbit
sudo ipfw add 10 pipe 1 tcp from any to me

Damit wird eine Pipe mit begrenzter Geschwindigkeit aufgesetzt, so dass die Daten im Simulator langsamer ankommen. Um das Ganze nachher wieder aufzuheben genügt:

3

sudo ipfw delete 10

• Filmschnipsel können jetzt auch als Kopie abgespeichert werden
• Sprachsteuerung über Bluetooth-Headsets wir möglich
• Haptisches Feedback durch Vibration, wenn man die Anordnung der Home Apps verschiebt
• Optimierung von OpenGL
• API-Schnittstelle erlaubt Drittanbietern den Zugriff auf die 3GS-Videos

Im SDK stehen neue Methoden zur Verfügung, um Push Notifications einzubinden. Diese werden im Application Delegate untergebracht und werden vom iPhone entsprechend den eingehene Notifications aufgerufen. Dabei sind die Schritte immer dieselben:

1. Registrieren beim Apple Notification Server (APNS). Dies ist bei jedem Start erforderlich und geschieht mittels: registerForRemoteNotificationTypes
2. Danach ruft das iPhone OS eine der beiden Methoden auf. Im Falle einer erfolgreichen Registrierung:
   didReceiveRemoteNotification, falls nicht didFailToRegisterForRemoteNotificationsWithError.

Das war’s dann leider auch schon fast, was das SDK zu bieten hat. Leider wird beispielweise didRecieveNotification nur aufgerufen, wenn die Applikation gerade geöffnet ist. Erscheint jedoch die bekannte Alert Box, die einem auf eine Push Notification hinweist, wird die eigene iApp zwar gestartet, allerdings ist das Vorgehen dann anders, um darauf zu reagieren. Hier wurde eine weitere Methode eingefüht, die es  erlaubt, sogenante Launch Options beim Aufstarten abzufragen, ähnlich von Command Line Parametern auf Desktop Rechner. Auf dem iPhone heisst die entsprechende Methode didFinishLaunchingWithOptions:(NSDictionary *)launchOptions; die es zu implementieren gilt. Dabei ist der wichtige Parameter launchOptions, in dem mittels des Keys UIApplicationLaunchOptionsRemoteNotificationKey die notwendigen Push Infos abgefragt werden können, was dann ungefähr so aussieht:

1

NSDictionary* userInfo = [launchOptions valueForKey:@"UIApplicationLaunchOptionsRemoteNotificationKey"];

So haben wir nun iPhone seitig alles zusammen, um Push Notifications einzubinden. Alles Andere erfolgt ausschliesslich auf dem APNS und dem eigenen Server. Eine Herausforderung bleibt dabei das Testing und wie das am Besten zu bewerkstelligen ist, beschreibe ich im nächsten Topic of the Week.