Erstellen der Listen-Ansicht für Anreden

Wir erstellen nun einfach eine neue Subklasse von “UITableViewController” namens “AnredenListeViewController”. Hier werden später die Anreden verwaltet.

Zunächst erweitern wir den HauptMenuViewController.m dahingehend dass bei einem Klick auf “Anreden” der “AnredenListeViewController” geladen wird:

#import "AnredenListeViewController.h"

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
    if (indexPath.row == 1) {
        AnredenListeViewController *alvc = [[AnredenListeViewController alloc] initWithStyle:UITableViewStylePlain];
        [self.navigationController pushViewController:alvc animated:YES];
    }
}

Wenn man das Programm startet kann man im Hauptmenü auf “Anreden” klicken und landet in einer leeren Liste.

AnredenListeViewController.h erweitern

Wir erweitern nun mal den Listen-Controller für Anreden im Header-File (AnredenListeViewController.h) und fügen einige Variablen und Methoden hinzu:

@interface AnredenListeViewController : UITableViewController <UIAlertViewDelegate>

@property (nonatomic, retain) NSArray *anreden;

- (void)anredenLaden;
- (void)anredeHinzufuegen;
- (void)anredeLoeschen;

@end

• In dem Array “anreden” werden alle Anreden aus der Datenbank/CoreData gespeichert.
• Die Methode “anredenLaden” wird zuständig sein um die Anreden aus CoreData in das Array “anreden” zu laden
• Die Methode “anredeHinzufuegen” wird aufgerufen wenn man auf einen Button für das Hinzufügen von Anreden klickt
• Die Methode “anredeLoeschen” wird aufgerufen wenn auf den “Löschen” Button geklickt wird. Die Tabelle schaltet sich dann in den Modus zum Löschen von Einträgen

Button für das Hinzufügen und Löschen einfügen

In dem ViewController sollen obren rechts zwei Button erscheinen. Einer zum Löschen und einer zum Hinzufügen von Anreden. Wir erweitern hierfür den AnredenListeViewController.m:

#import "AppDelegate.h"

@implementation AnredenListeViewController

@synthesize anreden;

- (id)initWithStyle:(UITableViewStyle)style
{
    self = [super initWithStyle:style];
    if (self) {
        self.anreden = [[NSMutableArray alloc] init];
    }
    return self;
}

- (void)viewDidLoad
{
    [super viewDidLoad];

    // Titel setzen
    self.title = @"Anreden";

    UIBarButtonItem *loeschButton = [[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemTrash
                                                                                  target:self
                                                                                  action:@selector(anredeLoeschen)];

    UIBarButtonItem *hinzufButton = [[UIBarButtonItem alloc] initWithBarButtonSystemItem:UIBarButtonSystemItemAdd
                                                                                  target:self
                                                                                  action:@selector(anredeHinzufuegen)];

    self.navigationItem.rightBarButtonItems = [NSArray arrayWithObjects:loeschButton, hinzufButton, nil];
}

Oben rechts erscheinen nun die Buttons mit dem “Löschen” und “Hinzufügen” Symbol. Klickt man auf “Hinzufügen” wird folgende Methode aufgerufen:

- (void)anredeHinzufuegen
{
    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"Neue Anrede"
                                                    message:@"Wie lautet die neue Anrede ?"
                                                   delegate:self
                                          cancelButtonTitle:@"Abbruch"
                                          otherButtonTitles:@"OK", nil];
    alert.alertViewStyle = UIAlertViewStylePlainTextInput;
    [alert show];
}

In dieser Methode wird einach nur ein AlertView mit einem Text-Eingabefeld angezeigt. Wird dies bestätigt wird folgende Methode aufgerufen:

#pragma mark - UIAlertView Delegate Methoden

- (void)alertView:(UIAlertView *)alertView clickedButtonAtIndex:(NSInteger)buttonIndex
{
    if (buttonIndex != [alertView cancelButtonIndex]) {
        NSString *neueAnredeText = [[alertView textFieldAtIndex:0] text];
        if ([neueAnredeText length] > 0) {
            // Nun kommt der erste Kontakt mit CoreData  

            // Context aus dem AppDelegate holen
            AppDelegate *delegate = [UIApplication sharedApplication].delegate;
            NSManagedObjectContext *context = delegate.managedObjectContext;

            // Neues Managed Objekt erstellen
            NSManagedObject *neueAnrede = [NSEntityDescription insertNewObjectForEntityForName:@"Anrede"
                                                                        inManagedObjectContext:context];

            // Wert setzen
            [neueAnrede setValue:neueAnredeText forKey:@"name"];

            // Speichern
            NSError *error;
            if (![context save:&error])
            {
                NSLog(@"Konnte nicht speichern: %@", [error localizedDescription]);
            }
            else
            {
                [self anredenLaden];
                [self.tableView reloadData];
            }
        }
    }
}

Wuhuuu, hier nun endlich Action mit CoreData! Nacheinander wird folgendes getan:

• Wir holen uns den CoreData “Kontext” aus dem AppDelegate. Dieser Kontext ist für alle Aktionen wie Laden/Speichern zuständig. Diese Programmzeile wird uns noch öfters begegnen.
• Danach wird ein neues Objekt “NSManagedObject” erzeugt mit der “Schablone” namens “Anrede” welches wir durch den grafischen CoreData-Model-Editor definiert haben
• Dann wird der Wert/Attribut “name” gesetzt mit dem Inhalt des Textfeldes aus dem AlertView
• Mittels [context save:&error] wird dann die neue Anrede im CoreData-Kontext gespechert

Zuguterletzt werden wieder alle Anreden neu geladen, aber diese Methode haben wir noch nicht geschrieben.

Laden der Anreden

In dieser Methode werden alle Anreden von CoreData in das Array “anreden” geladen:

-(void)anredenLaden
{
    // Laden der Anreden von Core Data
    // Zuerst Context holen
    AppDelegate *delegate = [UIApplication sharedApplication].delegate;
    NSManagedObjectContext *context = delegate.managedObjectContext;

    // Wir erstellen ein FetchRequest
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];

    // Dann holen wir uns die Beschreibung für eine Anrede
    NSEntityDescription *anredeEntity = [NSEntityDescription entityForName:@"Anrede"
                                                    inManagedObjectContext:context];

    // Setzen die Entity für den FetchRequest
    fetchRequest.entity = anredeEntity;

    // FetchRequest "absenden"
    NSError *error;
    self.anreden = [context executeFetchRequest:fetchRequest error:&error];
}

• Wir holen uns als erstes wieder den Kontext
• Dann erstellen wir uns einen FetchRequest. Dieses Objekt ist zuständig um Objekte von CoreData zu laden
• Wir erstellen die “NSEntityDescription” und setzen diese im FetchRequest. Das bedeutet dass unser FetchRequest Entitäten vom Typ “Anrede” holen soll.
• Zuguterletzt wird der FetchRequest “abgeschickt” und das Resultat ist ein Array von NSManagedObjects welche in self.anreden gespeichert wird

Nun haben wir den Code um alle Anreden aus CoreData in ein Array zu laden, aber angezeigt wird noch nix. Wir erweitern nun den Code mit den UITableViewDataSource-Methoden.

Methoden zur Anzeige von Anreden (UITableViewDataSource)

Wir erweitern den Code wie folgt:

#pragma mark - Table view data source

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    return [anreden count];
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *CellIdentifier = @"Cell";

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    if (cell == nil) {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier];
    }

    // Configure the cell...
    NSManagedObject *anredeObjekt = [self.anreden objectAtIndex:indexPath.row];
    cell.textLabel.text = [anredeObjekt valueForKey:@"name"];

    return cell;
}

Hier sollte nicht viel Neues zu sehen sein. In tableView:numberOfRowsInSection: wird die Anzahl der Anreden zurückgegeben. So viele Zeilen sollen angezeigt werden.

In tableView:cellForRowAtIndexPath: wird die Anrede (NSManagedObject) aus self.anreden herausgeholt und der Name in das TextLabel der Zelle geschrieben.

Löschen von Anreden

Bisher hat unser “Löschen” Button noch keine Funktion. Beim Klick auf diesen wird ja nur die bisher leere Methode “anredeLoeschen” aufgerufen. Diese bekommt ein wenig “Leben”:

- (void)anredeLoeschen
{
    self.tableView.editing = !self.tableView.editing;
}

Gaaaaanz einfach: es wird lediglich der “Editing” Modus ein/ausgeschaltet. Ihr könnt das mal ausprobieren: man sieht dann einfach nur die Steuerung zum Löschen von Einträgen (roter Punkt vorne, wenn man darauf klickt das “Lösch”-Feld rechts).

Klickt man jedoch auf Löschen passiert noch nix. Hierfür muss man folgende Methode erweitern:

- (void)tableView:(UITableView *)tableView commitEditingStyle:(UITableViewCellEditingStyle)editingStyle forRowAtIndexPath:(NSIndexPath *)indexPath
{
    if (editingStyle == UITableViewCellEditingStyleDelete) {

        // Das  zu löschende Objekt holen
        NSManagedObject *loeschObjekt = [self.anreden objectAtIndex:indexPath.row];

        // Das Managed Objekt löschen, zuerst aber wieder den Context holen
        AppDelegate *delegate = [UIApplication sharedApplication].delegate;
        NSManagedObjectContext *context = delegate.managedObjectContext;

        // Objekt aus Context löschen
        [context deleteObject:loeschObjekt];

        // In Datenbank speichern
        NSError *error;
        if (![context save:&error])
        {
            NSLog(@"Konnte nicht löschen: %@", [error localizedDescription]);
        }
        else
        {
            [self anredenLaden];
            [self.tableView reloadData];
        }
    }
}

• Zuerst holen wir das Objekt welches zum Löschen markiert wurde
• Dann wird wieder der “Kontext” geholt
• Mittels [context deleteObject:loeschObjekt] wird dieses Objekt aus dem Kontext gelöscht
• Und zuguterletzt speichern wird dies mit [context save:&error] im Kontext

Zusammenfassung

Das war es zum zweiten Teil unseres Tutorials. Wir haben bis jetzt: Daten aus CoreData gelesen, neue hinzugefügt und Daten wieder heraus gelöscht.

Bisher haben wir nur ganz einfach Daten bearbeitet, um genau zu sein nur eine Entität namens “Anrede” welche auch nur ein “Attribut” namens “name” vom Typ String.

Im nächsten Teil gehen wir an komplexere Masken über zum Bearbeiten von Kontakten.

In der folgenden Tutorial-Serie versuche ich eine kleine App aufzubauen mit der man “Kontak-Daten” verwalten kann. Eine einfache Datenbank mit Kontakten welche aus Vorname, Nachname, E-Mail-Adresse, Geburtstag und einer Anrede besteht. In jedem Teil wird die App etwas erweitert, ich hoffe so erleichtere ich den schrittweisen Einstieg in die Materie

Los geht’s, wir starten XCode und erstellen ein Projekt mit dem Template “Master Detail Application”. Wir nennen das Projekt “CoreDataAdressen” und haken unten an “Use CoreData” und “Use Automatic Reference Counting”:

Als nächstes den “MasterViewController” und “DetailViewController” komplett löschen, wir wollen “blankes” Projekt haben. Durch das Template wurden im AppDelegate aber alle CoreData-relevanten Infos erstellt die wir im späteren Verlauf benötigen um auf die Daten zuzugreifen.

Erstellen des Hauptmenüs

Die erste Maske in unserem Projekt soll eine einfach TableView sein, in der man 2 Menüpunkte auswählen kann: “Kontakte” und “Anreden”. Wir erstellen also einen neuen ViewController als Unterklasse von “UITableViewController” (ohne XIB File) namens HauptMenuViewController:

Das Projekt sollte bis jetzt ungefähr so aussehen:

Änderung des AppDelegates

Bisher noch nichts spannendes. Unser Template hat ja normalerweise vorgesehen dass der MasterViewController geladen wird. In unserem Projekt soll aber als erstes der “HauptMenuViewController” geladen werden. Im AppDelegate.m folgende Änderung vornehmen:

#import "HauptMenuViewController.h"

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
    // Override point for customization after application launch.

    HauptMenuViewController *hauptmenu = [[HauptMenuViewController alloc] initWithStyle:UITableViewStylePlain];
    self.navigationController = [[UINavigationController alloc] initWithRootViewController:hauptmenu];
    self.window.rootViewController = self.navigationController;
    [self.window makeKeyAndVisible];
    return YES;
}

Menüpunkte in HauptMenuViewController einfügen

Nun wird beim Start der “HauptMenuViewController” geladen, welcher aber im Moment nur ein leerer TableViewController ist. Hier wollen wir ja 2 Auswahlmöglichkeiten haben: “Kontakte” und “Anreden”. Also ändern wir den HauptMenuViewController.m:

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    return 2;
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *CellIdentifier = @"Cell";

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    if (cell == nil) {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier];
    }

    if (indexPath.row == 0) {
        cell.textLabel.text = @"Adressen";
    }
    else if (indexPath.row == 1) {
        cell.textLabel.text = @"Anreden";
    }
    cell.accessoryType = UITableViewCellAccessoryDisclosureIndicator;

    return cell;
}

Erster Kontakt mit CoreData, dem CoreData Model Editor

Nun kommen wir zu unserem ersten Kontakt mit dem Modellieren der CoreData-Entitäten / Objekten. In unserem Projekt gibt es ja eine Datei namens “CoreDataAdressen.xcdatamodeld”. Dies stellt unsere “Beschreibung” für unsere Daten-Objekte dar welche man mittels eines grafischen Editors bearbeiten kann.

Standardmässig ist eine Beispiel-Entität namens “Event” dort aufgeführt, diese kann man löschen oder ignorieren. Wir legen 2 weitere Entitäten an, zu erst einmal “Anrede”:

Bei dieser neuen Enität fügt Ihr einfach nur ein Feld “name” vom Typ “String” hinzu, Anreden bestehen in unserem Daten-Modell nur aus diesem einen Attribut.

Und dann die Entität welche unsere Kontakte beschreibt (namens “Kontakt”):

Ein Kontakt besteht in unserem Beispiel aus “vorname”, “nachname” und “email” vom Typ “String” und ein Feld namens “geburtstag” vom Typ “Date”. Desweiteren fügen wir noch ein “Beziehung”, also Relationship zur Tabelle “Anrede” hinzu (s. Screenshot).

Nun könnte es krachen

Wenn Ihr das Programm mehrmals gestartet habt und dann das DataModel ändert kann es beim Start zu folgendem Fehler kommen:

2012-01-21 13:44:24.858 CoreDataAdressen[17284:fb03] Unresolved error Error Domain=NSCocoaErrorDomain Code=134100 "The operation couldn’t be completed. (Cocoa error 134100.)" UserInfo=0x6d9c790 {metadata={type = immutable dict, count = 7,
entries =>
2 : {contents = "NSStoreModelVersionIdentifiers"} = {type = immutable, count = 1, values = (
0 : {contents = ""}
)}
4 : {contents = "NSPersistenceFrameworkVersion"} = {value = +386, type = kCFNumberSInt64Type}
6 : {contents = "NSStoreModelVersionHashes"} = {type = immutable dict, count = 1,
entries =>
0 : {contents = "Event"} = {length = 32, capacity = 32, bytes = 0x5431c046d30e7f32c2cc809958add1e7 ... 846e97d7af01cc79}
}

7 : {contents = "NSStoreUUID"} = {contents = "D51A5A5F-1122-4CB1-8064-80236FD48CC5"}
8 : {contents = "NSStoreType"} = {contents = "SQLite"}
9 : {contents = "_NSAutoVacuumLevel"} = {contents = "2"}
10 : {contents = "NSStoreModelVersionHashesVersion"} = {value = +3, type = kCFNumberSInt32Type}
}
, reason=The model used to open the store is incompatible with the one used to create the store}, {
metadata = {
NSPersistenceFrameworkVersion = 386;
NSStoreModelVersionHashes = {
Event = <5431c046 d30e7f32 c2cc8099 58add1e7 579ad104 a3aa8fc4 846e97d7 af01cc79>;
};
NSStoreModelVersionHashesVersion = 3;
NSStoreModelVersionIdentifiers = (
""
);
NSStoreType = SQLite;
NSStoreUUID = "D51A5A5F-1122-4CB1-8064-80236FD48CC5";
"_NSAutoVacuumLevel" = 2;
};
reason = "The model used to open the store is incompatible with the one used to create the store";
}

Dieser Fehler sagt aus dass das DataModel bei den vorherigen Starts anders ausgesehen hat. Inzwischen haben wir ja die Entities “Anrede” und “Kontakt” hinzugefügt. Wenn man das Programm danach startet hat sich das DataModel geändert und damit kommt CoreData im Moment noch nicht klar.

Dies lässt sich aber mit einer einfach Anpassung im AppDelegate korrigieren. Das Ganze fällt unter das Stichwort “CoreData Data Migration / Versioning”: jedes Mal wenn was am Daten-Modell geändert wird müssen wir CoreData sagen wie sich die Daten ändern. Wenn aber nur leichte Änderungen am Daten-Modell hinzugefügt werden kann man dies durch folgende Änderung am AppDelegate beheben:

- (NSPersistentStoreCoordinator *)persistentStoreCoordinator
{
    if (__persistentStoreCoordinator != nil)
    {
        return __persistentStoreCoordinator;
    }

    NSURL *storeURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:@"CoreDataAdressen.sqlite"];

    NSDictionary *options = [NSDictionary dictionaryWithObjectsAndKeys:
                             [NSNumber numberWithBool:YES], NSMigratePersistentStoresAutomaticallyOption,
                             [NSNumber numberWithBool:YES], NSInferMappingModelAutomaticallyOption, nil];

    NSError *error = nil;
    __persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:[self managedObjectModel]];
    if (![__persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType
                                                    configuration:nil
                                                              URL:storeURL
                                                          options:options
                                                            error:&error])
    {
...

Beim Erstellen des Objekts “persistentStoreCoordinator” geschieht dies nun mit den Optionen “NSMigratePersistentStoresAutomaticallyOption” und “NSInferMappingModelAutomaticallyOption”. Wenn man das Programm nun startet kommt es nicht mehr zu einem Absturz.

Im nächsten Teil der Tutorial-Serie erweitern wir das Programm so dass man Anreden hinzufügen, löschen und anzeigen kann.

Die Lösung ist sehr einfach: Einfach unter “Build Phases” bei “Link Binary with Libraries” die Library “libSystem.B.dylib” als “Optional” hinzufügen.

Ergänzung: Nachdem ich dies so genutzt habe lies sich die App unter Xcode4 ganz normal für iOS Geräte compilieren, brachte aber einen Compiler-Fehler wenn ich sie im Simulator compilieren wollten.

Die Lösung gab es natürlich auf .

Ins deutsche übersetzt müsst Ihr folgendes machen:

• Das Terminal aufrufen und in den Ordner /Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator5.0.sdk/usr/lib wechseln
• Einen symbolischen Link anlegen mittels: sudo ln -s libSystem.dylib libSystem.B.dylib
• Dann sollte die App wieder im Simulator laufen

Nachtrag für Xcode 4.3

Ab XCode 4.3 befindet sich XCode im Programme-Verzeichnis. Der Pfad zu den Bibliotheken ist dann /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator5.0.sdk/usr/lib

NSMutableArray *neueVC = [NSMutableArray arrayWithArray:tabController.viewControllers];
[neueVC removeObjectAtIndex:2];
tabController.viewController = neueVC;

Eine Möglichkeit dies zu realisiern ist z.B. mit Pre-Processor-Makros und einer einfachen Abfrage im Programmcode.

Hier die Vorgehensweise:

- Duplizieren des vorhandenen “Targets”, so dass man ein 2. Target namens “App copy” hat.
- In diesem neuen Target kann man komplett anderer Bundle Identifier etc. nutzen um die App unter einem anderen Namen im App-Store zu vertreiben
- Unter “Build Settings” des Targets einfach nach “other c” filtern und auf “Other C Flags” klicken:

- Hier einfach “-DKUNDE_VERSION” oder “-DLITE_VERSION” einfügen
- Das war’s auch schon

Im Programmcode an sich kann man ganz einfach zwischen beiden Versionen unterscheiden, in dem man z.B. folgenden Programmcode verwendet:

#ifdef KUNDE_VERSION
// Code welcher in der LITE-Version ausgeführt werden soll
#else
// Code welcher in der "normalen" Version ausgeführt werden soll
#endif

Zuerst der Fehler:
Wenn Ihr mit der Library/Klasse “PHPMailer” in PHP arbeitet und Mails damit versendet, so kommen Mails mit scheinbar “fehlendem Attachment” im Apple Mail-Client an wenn Ihr in der gleichen Mail auch mit eingebetteten Bildern (“Embedded Images”) arbeitet.

Lösung:
- Ihr benötigt zuerst die aktuelle Version vom PHPMailer, Version 5.1, diese könne Ihr hier herunterladen
- Es gibt zu diesem Problem ein extra Patch-File welches unter hier herunterzuladen ist
- Wendet einfach den Patch auf die Datei an (Unter MAC OS hierfür das Terminal öffnen, beide Dateien in ein Verzeichnis verschieben und in der Kommandozeile “patch class.phpmailer.php phpmailer.patch” ausführen)

Nun werden die Boundaries wieder korrekt verschachtelt und die Mail sollte im Apple-Mail-Client und anderen Mail-Clients wieder korrekt lesbar sein (inkl. aller Attachments)

Wenn Ihr mehrere Buttons haben wollt könnt Ihr ein UISegmentedControll erstellen und dies quasi als UIBarButtonItem nutzen. Hier der Beispiel-Code:

    // Segmented Control erstellen
    UISegmentedControl* segmentedControl = [[UISegmentedControl alloc] initWithItems:[NSArray array]];

    // Man soll nicht sehen dass ein Segment selektiert wurde
    [segmentedControl setMomentary:YES];

    // Fügt Segmente hinzu, alternativ kann man auch insertSegmentWithImage:atIndex:animated: nutzen um Bilder zu benutzen
    [segmentedControl insertSegmentWithTitle:@"Historie" atIndex:0 animated:NO];
    [segmentedControl insertSegmentWithTitle:@"Bearbeiten" atIndex:1 animated:NO];

    // Wird für Autoresizing genutzt
    segmentedControl.autoresizingMask = UIViewAutoresizingFlexibleWidth;

    // Setzt des Stil der SegmentedControl
    segmentedControl.segmentedControlStyle = UISegmentedControlStyleBar;

    // Aktion welche erfolgt wenn man auf die SegmentedControl klickt
    [segmentedControl addTarget:self action:@selector(eineAktion:) forControlEvents:UIControlEventValueChanged];

    // Erstellt ein BarButtonItem und fügt es als rightBarButtonItem hinzu
    UIBarButtonItem *segmentBarItem = [[UIBarButtonItem alloc] initWithCustomView: segmentedControl];
    self.navigationItem.rightBarButtonItem = segmentBarItem;

    // Objekt releasen
    [segmentedControl release];

Ich hatte dummerweise ein .m-File mittels #import ins Projekt eingebunden. Kann ja mal aufgrund der Auto-Completion passieren

Ich habe ein neues Projekt (view-based Application) angelegt und ein ganz einfaches Interface gestaltet: Auf den View habe ich einen Button angelegt – und wenn man auf diesen klickt wird die Action getAddress: aufgerufen.
So sieht das Header-File meines ViewControllers aus:

#import <UIKit/UIKit.h>
#import <AddressBook/AddressBook.h>
#import <AddressBookUI/AddressBookUI.h>

@interface ABPickerTestViewController : UIViewController <ABPeoplePickerNavigationControllerDelegate> {

}
- (IBAction)getAddress:(id)sender;

Man muss also das Protokoll “ABPeoplePickerNavigationControllerDelegate” implementieren. Hier der komplett Code der .m-Files. Ich erkläre diesen später:

- (IBAction)getAddress:(id)sender {
    ABPeoplePickerNavigationController *pp = [[ABPeoplePickerNavigationController alloc] init];
    pp.peoplePickerDelegate = self;
    [self presentModalViewController:pp animated:YES];
    [pp release];
}

#pragma mark -
#pragma mark ABPeoplePickerNavigationControllerDelegate

- (BOOL)peoplePickerNavigationController:(ABPeoplePickerNavigationController *)peoplePicker
      shouldContinueAfterSelectingPerson:(ABRecordRef)person
{
    // "Normale" Infos
    NSString *vorname = (NSString *)ABRecordCopyValue(person, kABPersonFirstNameProperty);
    NSString *nachname = (NSString *)ABRecordCopyValue(person, kABPersonLastNameProperty);
    NSString *firma = (NSString *)ABRecordCopyValue(person, kABPersonOrganizationProperty);

    NSLog(@"Vorname: %@", vorname);
    NSLog(@"Nachname: %@", nachname);
    NSLog(@"Firma: %@", firma);

    [vorname release];
    [nachname release];
    [firma release];

    // Infos zu Telefonnummern
    ABMultiValueRef multi = ABRecordCopyValue(person, kABPersonPhoneProperty);
    for (CFIndex i = 0; i < ABMultiValueGetCount(multi); i++) {

        NSString *telLabel = (NSString *)ABMultiValueCopyLabelAtIndex(multi, i);
        NSString *telNr = (NSString *)ABMultiValueCopyValueAtIndex(multi, i);

        NSString *typ = @"";
        if ([telLabel rangeOfString:@"Work"].location != NSNotFound) {
            typ = @"Arbeit";
        }
        else if ([telLabel rangeOfString:@"Mobile"].location != NSNotFound) {
            typ = @"Mobil";
        }
        else if ([telLabel rangeOfString:@"Home"].location != NSNotFound) {
            typ = @"Heim";
        }
        else {
            typ = @"unbekannt";
        }

        NSLog(@"Label: %@ Nr: %@ Typ: %@", telLabel, telNr, typ);

        [telLabel release];
        [telNr release];
    }
    CFRelease(multi);

    // Infos zu Adressen
    ABMultiValueRef address = ABRecordCopyValue(person, kABPersonAddressProperty);
    for (CFIndex i = 0; i < ABMultiValueGetCount(address); i++) {

        NSString *addrLabel = (NSString *)ABMultiValueCopyLabelAtIndex(address, i);
        NSDictionary *addrDict = (NSDictionary *)ABMultiValueCopyValueAtIndex(address, i);

        NSString *strasse = [addrDict objectForKey:@"Street"];
        NSString *plz = [addrDict objectForKey:@"ZIP"];
        NSString *ort = [addrDict objectForKey:@"City"];

        NSLog(@"Label: %@ Str: %@, PLZ: %@, Ort: %@", addrLabel, strasse, plz, ort);

        [addrLabel release];
        [addrDict release];
    }
    CFRelease(address);

    // ModalViewController dismissen
    [self dismissModalViewControllerAnimated:YES];
    return NO;
}

- (BOOL)peoplePickerNavigationController:(ABPeoplePickerNavigationController *)peoplePicker
     shouldContinueAfterSelectingPerson:(ABRecordRef)person
                               property:(ABPropertyID)property
                             identifier:(ABMultiValueIdentifier)identifier
{
    return NO;
}

- (void)peoplePickerNavigationControllerDidCancel:(ABPeoplePickerNavigationController *)peoplePicker
{
    [self dismissModalViewControllerAnimated:YES];
}

Nehmen wir uns zuerst einmal die Action vor die aufgerufen wird wenn der Button geklickt wird:

- (IBAction)getAddress:(id)sender {
    ABPeoplePickerNavigationController *pp = [[ABPeoplePickerNavigationController alloc] init];
    pp.peoplePickerDelegate = self;
    [self presentModalViewController:pp animated:YES];
    [pp release];
}

Hier wird zuerst ein Objekt initialisiert welches im Framework “AddressBookUI” vorkommt, nämlich den “ABPeoplePickerNavigationController“. Ihr kennt diesen Controller, das ist der gleiche wenn man das Adressbuch öffnet und in den Kontakten sucht.
Diesem Controller wird ein Delegate bekannt gemacht, der Einfachheit halber nehmen wir das gleiche Objekt (self), im Interface haben wir ja auch gesagt dass das Protokoll “ABPeoplePickerNavigationControllerDelegate” eingehalten wird.
Zuguterletzt wird der Controller als “ModalView” angezeigt.

Das Verhalten des “ABPeoplePickerNavigationController” richtet sich nach den Delegate-Methoden welche wir eingeführt haben.

Fangen wir mit den einfachsten an:

- (void)peoplePickerNavigationControllerDidCancel:(ABPeoplePickerNavigationController *)peoplePicker
{
    [self dismissModalViewControllerAnimated:YES];
}

Diese Delegate-Methode wird aufgerufen wenn der “Abbruch” Button geklickt wird, in unserem Falle entfernen wir einfach den ModalView.

- (BOOL)peoplePickerNavigationController:(ABPeoplePickerNavigationController *)peoplePicker
     shouldContinueAfterSelectingPerson:(ABRecordRef)person
                               property:(ABPropertyID)property
                             identifier:(ABMultiValueIdentifier)identifier
{
    return NO;
}

Diese Delegate Methode wird aufgerufen wenn der User eine der User-Eigenschaften anklickt. In unserem Fall tritt dies nicht ein da die nächste Delegate-Methode gar nicht zulässt dass man in einen Benutzer reinspringt:

- (BOOL)peoplePickerNavigationController:(ABPeoplePickerNavigationController *)peoplePicker
      shouldContinueAfterSelectingPerson:(ABRecordRef)person
{
    // Jede Menge Code hier, s. oben

    // ModalViewController dismissen
    [self dismissModalViewControllerAnimated:YES];
    return NO;
}

Diese Delegate-Methode wird aufgerufen sobald man in der Kontakt-Liste einen Kontakt anklickt. Die Rückgabe NO gibt an dass nicht in den Benutzer reingesprungen wird sondern er direkt ausgewählt wird. Im Quellcode sind einige Beispiele aufgeführt wie man an Informationen des Eintrags kommt, ich hoffe Ihr könnt damit was anfangen

if ([haystackString rangeOfString:@"needle"].location != NSNotFound) {
    // Das Wort "needle" kommt in dem String haystackString vor!
}