In questo nuovo tutorial vedremo come realizzare una cosa molto particolare, che potrà tornare utile soprattutto quando distrubuirete l’applicazione a diversi beta tester.

Vedremo, infatti, come inserire all’interno del nostro progetto (oltre al classico numero di versione dell’applicazione) un numero di build progressimo, insieme anche alla data della build in questione.

Utilizzeremo uno script automatico, che ad ogni build creata aumenterà il numero di build e aggiornerà la data della build Potremo, così, avere sempre sotto controllo l’esatta versione della nostra applicazione, in modo da avere un controllo completo su tutte le versioni.

Buon tutorial!

1. Inseriamo lo script

Entriamo nel progetto in cui vogliamo inserire l’incremento automatico del numero di versione. Facciamo clic con il tasto destro sul nome del nostro progetto e scegliamo “Add -> New Build Phase -> New Run Script Build Phase”.

Si aprirà una schermata come questa:

in cui dovremo andare ad inserire lo script necessario. Eccovelo:

#!/bin/bash
# Auto Increment Version Script
buildPlist="prova-Info.plist"
CFBuildNumber=$(/usr/libexec/PlistBuddy -c "Print CFBuildNumber" $buildPlist)
CFBuildNumber=$(($CFBuildNumber + 1))
<div id="_mcePaste">/usr/libexec/PlistBuddy -c "Set :CFBuildNumber $CFBuildNumber" $buildPlist
CFBuildDate=$(date)
/usr/libexec/PlistBuddy -c "Set :CFBuildDate $CFBuildDate" $buildPlist</div>

Ovviamente dovete modificare la stringa buildPlist=”prova-Info.plis”, inserendo il nome del vostro file “.plist” (che sarà nella forma “nome_progetto-Info.plist”).

Chiudete pure tale finestra.

2. Inseriamo le variabili necessarie

Spostatevi, ora, nella cartella “Resources” ed aprite il file “xxx-Info.plist” che trovate al suo interno (dove xxx è il nome del vostro progetto).

Utilizzando il “+” che appare di fianco alle voci già presenti, inserite due nuovi valori, rispettivamente chiamati “CFBuildDate” e “CFBuildNumber“. Non c’è bisogno che inseriate dei valori per queste due voci, in quanto verranno create automaticamente dallo script. Ecco come deve essere il vostro file “.plist”:

Potete notare che è già presente la stringa “Bundle version“, che identifica la versione della nostra applicazione. Sarà anche questo un valore che andremo a leggere. Salvate il file e chiudetelo pure.

3. Inseriamo il codice necessario

Non ci resta che inserire quelle poche istruzioni che ci permetteranno di leggere il numero di versione, il numero di build e la data dell’ultima build. Inserite, dove vi serve, il seguente codice:

1
2
3

NSString *versione = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBundleVersion"];
NSString *build = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBuildNumber"];
NSString *data = [[[NSBundle mainBundle] infoDictionary] objectForKey:@"CFBuildDate"];

Come vedete abbiamo ottenuto tre stringhe con i rispettivi tre valori, che potrete utilizzare a vostro piacimento!

Se Avete Problemi, questo è il nostro file di progetto.

Nota: per visualizzare lo script inserito espandete l’elemento “Targets” del progetto e fate doppio clic su “Run Script“.

La guida è stata creata da Andrea Busi per “Bubi Devs”, prendendo spunto da questa guida: “Auto Increment Build Number & Date in XCode iPhone Project“. I meriti, quindi, sono del legittimo autore.

Nella prima parte del tutorial abbiamo visto come creare la struttura di base del nostro “Brushes”, inoltre abbiamo fatto in modo che l’utente possa disegnare all’interno dell’applicazione.

In questa seconda parte aggiungeremo alcuni aspetti fondamentali per migliorare l’applicazione: la possibilità di cambiare la dimensione e il colore del pennello, e la possibilità di salvare i disegni.

Vedremo, quindi, come due classi diverse possano comunicare tra loro, e come utilizzare il metodo “imageSavedToPhotosAlbum” che permette di salvare delle immagini nella galleria dell’utente.

Buon tutorial a tutti!

Leggi il tutorial completo su devAPP

Rieccoci con una nuova serie di tutorial!

Quello che ho pensato per voi questa volta è un po’ particolare, ma secondo me molto carino e con molte cose utili. Sicuramente tutti voi conoscerete Brushes (link iTunes), un programma molto famoso per disegnare sul proprio iPhone e iPod Touch.

Ho pensato, quindi, di spiegarvi come realizzarne uno tutto vostro! In questa prima parte vedremo come fare in modo che l’utente possa, muovendo il dito sullo schermo, disegnare a suo piacimento.

Ovviamente in questa prima parte ci occuperemo solo di questo aspetto. Nel prossimo tutorial vedremo, poi, come rendere possibile la definizione di un pennello personale, con dimensione e colore a scelta.

Ora, però, concentriamoci sulla prima parte. Buon tutorial a tutti!

Leggi il tutorial completo su devAPP

Eccoci con un nuovo tutorial dedicato alla programmazione per iPhone SDK.

In questo appuntamento vedremo come controllare le connessioni disponibili nel nostro dispositivo, operazione molto importante in tutte le applicazioni che devono accedere, per qualsiasi motivo, alla rete.

Vedremo come utilizzare la classe “Reachability” (messa a disposizione da Apple), per testare se è attiva una connessione WiFi o 3G. Piccola nota, in questo tutorial parleremo sempre di connessione 3G, sarebbe più corretto parlare di connessione dati (potrebbe essere anche una semplice connessione EDGE), ma per semplicità utilizzeremo sempre la dicitura 3G.

Buon tutorial a tutti allora!

Leggi il tutorial completo su devAPP

Eccoci giunti con l’ultimo appuntamento dei DevTutorial dedicato alla realizzazione di un semplice client per Twitter. Vi ricordo che trovate qui la prima parte, metre qui la seconda.

In questa terza parte vedremo come utilizzare la classe NSUserDefault, che ci permette di salvare delle informazioni relative alla nostra applicazione. Quello che andremo a salvare sarà la data in cui è stato eseguito l’ultimo refresh, che mostreremo all’avvio all’utente.

Ovviamente questa è una semplificazione, in applicazioni più complesse potremmo avere molte più informazioni da memorizzare (ad esempio dei settaggi come l’autorefresh, il nome utente o la password).

Prendiamo, quindi, in esame solo il salvataggio di un parametro, ma vedrete che non sarà nulla di difficile!

Leggi il tutorial completo su devAPP

Nella prima parte di questo tutorial abbiamo visto come aggiungere la libreria MGTwitterEngine e come leggere la nostra timeline di Twitter.

In questo secondo appuntamento vedremo, invece, come creare una tabella personalizzata, che dovrà visualizzare gli elementi Tweet che abbiamo salvato nella lista. Utilizzeremo, quindi,  la classe UITableViewCell per creare delle celle personalizzate, in modo da ottenere una tabella con un layout ad-hoc.

Vi ricordo che per seguire questo tutorial è necessario avere a disposizione il codice sorgente della prima parte.

Buon tutorial!

Leggi il tutorial completo su devAPP

Dopo una lunga attesa, eccoci con una nuova serie di tutorial!

Quello che inizieremo a realizzare oggi (e per un altro paio di tutorial successivi) sarà un nostro personalissimo client per Twitter! Vedremo, infatti, come sfruttare il progetto MGTwitterEngine, che ci permetterà di interagire con il nostro account di Twitter. Utilizzeremo, inoltre, degli aspetti più particolari e complessi dell’iPhone SDK.

Ecco quello che faremo oggi:

• Inserire la libreria MGTwitterEngine nel nostro progetto e settarla in maniera corretta;
• Collegarci, sfruttando tale libreria, alla nostro timeline di Twitter;
• Ricavare i vari tweet della timeline e salvarli in una lista con elemento ad-hoc.

Già che siamo in tema, vi ricordo che il nostro canale Twitter è raggiungibile a questo indirizzo, vi invito a seguirci se ancora non lo fate!

Ora sotto con il codice, buon tutorial a tutti!

Leggi il tutorial completo su devAPP

Eccoci con un nuovo tutorial dedicato alla programmazione per iPhone SDK. Oggi vedremo come implementare un database SQL all’interno delle nostre applicazioni. Creeremo una tabella in cui andremo ad inserire i valori letti dal nostro database, dopo aver eseguito una query predefinita.

Devo premettere, però, che non parlerò di SQL e database relazionali, che devono essere già conosciuti da chi affronta questo tutorial. È una scelta che potrebbe non piacere a molti di voi, però richiederebbe troppo tempo e una trattazione che non può essere fatta in un semplice tutorial. Detto ciò, è possibile seguire il tutorial anche senza conoscere niente di SQL, ovviamente alcune caratteristiche e alcuni passaggi potrebbero risultare di difficile comprensione.

Leggi il tutorial completo su devAPP

Con il firmware 2.2 Apple ha introdotto una classe davvero molto importante e potente, che permette di riprodurre una grande varietà di file audio all’interno delle proprie applicazioni. Tale classe è AVAudioPlayer e in questo tutorial vedremo come utilizzarla, creando un nostro rudimentale player audio.

Andremo a realizzare un’applicazione composta da due pulsanti, uno per avviare la riproduzione di un file audio, l’altro per fermare la riproduzione stessa. Il tutto è molto semplice, però potrà darvi gli strumenti necessari per utilizzare questa classe anche nelle vostre applicazioni! Buona programmazione allora!

1. Creiamo un nuovo progetto

Iniziamo come sempre creando un nuovo progetto di tipo “View-Based Application” e chiamiamolo “AVPlayerTutorial”.

Iniziamo definendo le due azioni che il nostro player musicale potrà eseguire, ovvero avviare e fermare la riproduzione di un brano. Apriamo, quindi, il file “AVPlayerTutorialViewController.h” e definiamo questi due metodi (righe 4 e 5):

1
2
3
4
5
6
7

@interface AVPlayerTutorialViewController : UIViewController  {
}
 
-(IBAction)avviaSuono;
-(IBAction)fermaSuono;
 
@end

Salviamo il file appena modificato e andiamo a creare la struttura grafica della nostra applicazione.

2. Definiamo l’interfaccia grafica

Facciamo doppio clic sul file “AVPlayerTutorialViewController.xib”, si aprirà Interface Builder in cui andremo a definire l’interfaccia grafica. Dobbiamo semplicemente inserire due bottoni, uno per avviare la riproduzione (un classico “Play”) e uno per fermarla (un “Pause”). Ecco come appare la mia applicazione (molto spartana oserei dire ):

Ora dobbiamo collegare le due azioni che abbiamo definito in precedenza. Dal Pannello dei Documenti (“Tools -> Reveal in Document Window”) selezioniamo il “File’s Owner” e apriamo poi il “Connections Inspector”. Colleghiamo l’azione “avviaSuono” con il primo bottone, mentre “fermaSuono” con il secondo. Ecco come appare il pannello dopo aver eseguito i collegamenti:

Abbiamo già terminato con questa parte, possiamo salvare tutto e chiudere Interface Builder.

3. Definiamo la classe

Torniamo al file “AVPlayerTutorialViewController.h” e completiamo la definizione della classe nella seguente maniera:

1
2
3
4
5
6
7
8
9
10
11

#import <UIKit/UIKit.h>
#import <AVFoundation/AVFoundation.h>
 
@interface AVPlayerTutorialViewController : UIViewController <AVAudioPlayerDelegate> {
	AVAudioPlayer *player;
}
 
-(IBAction)avviaSuono;
-(IBAction)fermaSuono;
 
@end

Abbiamo definito un componente “player” (riga 5), che sarà l’oggetto che si occuperà di leggere il nostro file e di riprodurlo, il tutto in grande semplicità, vista la potenza e la versatilità di questo componente.

Potete notare, inoltre, che abbiamo definito anche il delegato <AVAudioPlayerDelegate> (riga 4), che ci fornirà dei metodi molto importanti.

Prima di definirne le azioni, dobbiamo inserire nel nostro progetto il framework necessario. Espandete la sezione “Targets” nel progetto, e cliccate con il tasto destro su “AVPlayerTutorial”, selezionando poi “Get Info”. Si aprirà una nuova schermata, in cui dobbiamo andare nella sezione “General”. Nell’angolo in basso a sinistra noteremo un bottone “+”, clicchiamo e si aprirà
un elenco di tutti i framework disponibili:

Selezioniamo “AVFoundation.framework”  e clicchiamo su “Add”. Avremo così aggiunto il framework necessario. Possiamo chiudere la schermata delle proprietà e tornare al codice.

Prima di definire le azioni, inserite un file audio nel vostro progetto, semplicemente trascinandolo in XCode. Questo sarà il file che il nostro player andrà a riprodurre.

4. Definiamo le azioni

Ora dobbiamo implementare le due azioni, “avviaSuono” e “fermaSuono” del nostro lettore. Iniziamo inserendo il seguente codice nel file “AVPlayerTutorialViewController.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

#import "AVPlayerTutorialViewController.h"
 
@implementation AVPlayerTutorialViewController
 
-(IBAction)avviaSuono{
	if(!player){//il file non è già avviato
		// Ricaviamo il percorso del file da riprodurre
		NSString* resourcePath = [[NSBundle mainBundle] resourcePath];
		resourcePath = [resourcePath stringByAppendingString:@"/billie.mp3"];
		NSError* err;
		// Inizializziamo il player con il percorso del file
		player = [[AVAudioPlayer alloc] initWithContentsOfURL:[NSURL fileURLWithPath:resourcePath] error:&err];
 
		if(err){//c'è stato un errore
			NSLog(@"Errore: %@", [err localizedDescription]);
		}
		else{//tutto ok, riproduciamo il file
			player.delegate = self;
			[player play];
		}
 
	}
	else{//il file è già in esecuzione oppure si riprende ad eseguirlo
		NSLog(@"Riavvio riproduzione!");
		[player stop];
		player = nil;
		[self avviaSuono];
	}
}
 
-(IBAction)fermaSuono{
	NSLog(@"Player fermato!");
	[player pause];
}

Analizziamo il codice appena scritto, iniziando dal metodo “avviaSuono” (riga 5). Troviamo subito un “if”, che controlla se il file non è già stato avviato: in tal caso esegue delle istruzioni che andremo poi ad esaminare, altimenti chiama il metodo play della classe AVAudioPlayer (che riproduce appunto il file audio).
All’interno del ciclo if, troviamo la dichiarazione e l’inizializzazione del file da riprodurre: con le prime due istruzioni ricaviamo il percorso del nostro file (che ovviamente deve essere inserito all’interno del nostro progetto), poi inizializziamo l’oggetto “player”. Prima di poterlo riprodurre, testiamo la variabile “err”, che ci riporta eventuali errori nella fase di inizializzazione (ad esempio relativo al file audio non trovato). Se non c’è stato nessun errore, viene riprodotto il file tramite l’istruzione [player play].

Il secondo metodo, “fermaSuono”, si occupa di mettere in pausa la riproduzione del file, richiamando il metodo “pause” sempre dell’oggetto “player”.

Ora non ci resta che implementare alcuni metodi richiesti dal delegato “AVAudioPlayerDelegate”. Ecco il codice da inserire:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

- (void)audioPlayerDidFinishPlaying:(AVAudioPlayer *)aplayer successfully:(BOOL)flag {
	[player autorelease];
	player = nil;
}
 
- (void)audioPlayerDecodeErrorDidOccur:(AVAudioPlayer *)player error:(NSError *)error {
	NSLog(@"Errore nel decodificare: %@", [error localizedDescription] );
}
 
- (void)audioPlayerBeginInterruption:(AVAudioPlayer *)player {
	NSLog(@"Interrotto!");
}
 
- (void)audioPlayerEndInterruption:(AVAudioPlayer *)player {
	NSLog(@"Fine dell'interruzione!");
}

Questi metodi servono per sapere quando la riproduzione viene interrotta oppure per comunicare eventuali errori nella decodifica del file.

Clicchiamo ora su “Build and Go!” e testiamo il nostro personalissimo player audio!!

Se Avete Problemi, questo è il nostro file di progetto.

La guida è stata creata da Andrea Busi per “Bubi Devs”, prendendo spunto da questo guida: “Playing Audio Files using the iPhone SDK“. I meriti, quindi, sono del legittimo autore.

Eccoci con il secondo tutorial dedicato alle TabBar. Nella prima lezione abbiamo visto come creare una struttura generale, composta da due sezioni. Oggi vedremo, invece, come inserire una UINavigationBar all’interno di una nuova sezione, e gestire il movimento tra le varie celle di una tabella. Ovvero, quando l’utente seleziona una determinata cella si aprirà una corrispondente vista che avremo definito con Interface Builder. La navigation bar, poi, ci permetterà di tornare alla tabella principale. Un po’ come avviene nel menù “Impostazioni” del’iPhone / iPod Touch!

Buon tutorial a tutti!

1. Creiamo un nuovo elemento per la TabBar

Iniziamo creando la classe che gestirà la nuova vista. Dal menù “File” scegliamo “New File…”, nel pannello che apparirà selezioniamo “UIViewController subclass” e chiamiamo questa nuova classe “TabellaController”.

Abbiamo già imparato a gestire una tabella in questa serie di tutorial, quindi non rispiegherò il codice utilizzato. Riutilizziamo gli stessi metodi, quindi inserite nel file “TabellaController.h” il seguente codice:

1
2
3
4
5
6
7
8

@interface TabellaController : UITableViewController {
	//array che conterrà gli elementi da visualizzare nella tabella
	NSArray *lista;
}
 
@property (nonatomic, retain) NSArray *lista;
 
@end

Mentre in “TabellaController.m” inserite questi metodi:

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

#import "TabellaController.h"
 
@implementation TabellaController
 
@synthesize lista;
 
- (void)awakeFromNib{
	// creiamo la lista e inseriamo una serie di elementi da visualizzare nella nostra tabella
	lista = [[NSArray alloc] initWithObjects:	@"iPhone", @"iPod", @"iPod Touch", @"iMac", @"iBook",
			 @"MacBook", @"MacBook Pro", @"Mac Pro", @"PowerBook", nil];
 
}
 
//setta il numero di sezioni della tabella
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView{
	return 1;
}
 
//setta il numero di righe della tabella
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section{
	//il numero di righe deve corrispondere al numero di elementi della lista
	return [lista count];
}
 
//settiamo il contenuto delle varie celle
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath{
 
	UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"cellID"];
 
	if (cell == nil){
		cell = [[[UITableViewCell alloc] initWithFrame:CGRectZero reuseIdentifier:@"cellID"] autorelease];
 
	}
 
	//inseriamo nella cello l'elemento della lista corrispondente
	cell.textLabel.text = [lista objectAtIndex:indexPath.row];
 
	return cell;
}

Insomma, la classica gestione delle UITableView

Salviamo entrambi i file e riapriamo “MainWindow.xib” per tornare in Interface Builder.

2. Definiamo l’aspetto del nuovo elemento

Dalla Libreria prendiamo un componente UINavigationController e inseriamolo nella tab bar, proprio come abbiamo fatto nello scorso tutorial per le due viste.

Proprio come abbiamo fatto in precedenza cambiamo il nome della scheda in “Tabella”. Ecco il risultato finale:

Ora non ci resta che inserire la tabella all’interno di questa vista. Dalla Libreria prediamo un componente UITableViewController e inseriamolo nella nostra vista. Il risultato che dovete ottenere è il seguente:

Ora dobbiamo solo collegare la classe alla tabella appena inserita. Dal Pannello dei Documenti (“Tools -> Reveal in Document Window”) navighiamo fino al seguente percorso:

Come mostrato in figura, selezioniamo il componente “Table View Controller” (che non è altro che la nostra tabella) e apriamo l’”Identity Inspector”. Dal menù Class scegliamo “TabellaController”:

Abbiamo così concluso con la creazione della nostra tabella. Salviamo tutto, torniamo in XCode e clicchiamo su “Build and Go!”: la tabella sarà ora presente e funzionante nell’applicazione!

3. Implementiamo due viste di dettaglio

Ora vediamo di analizzare un aspetto che molti utenti mi hanno chiesto via mail. Se noi volessimo associare un determinato file “xib” (ovvero creato con Interface Builder) ad una cella, come potremmo fare? In questa seconda parte del tutorial vedremo proprio di analizzare i passaggi necessari. Andremo a definire due viste, una che conterrà una foto dell’elemento “iPhone”, mentre un’altra che avviserà l’utente dell’assenza di informazioni per un determinato prodotto. Ovviamente potreste realizzare una vista con i dettagli per ogni prodotto presente nella tabella, ma il meccanismo rimane invariato.

Iniziamo creando due nuovi file xib, dal menù “File -> New File…” e scegliendo “Empty XIB”. Io ho chiamato il primo file “iPhoneDetail” e il secondo “OtherDetail”, ma nulla vieta di chiamarli in modo diverso!

Procediamo proprio come abbiamo fatto all’inizio dello scorso tutorial per le viste “PrimaVista” e “Seconda Vista”, quindi definiamo subito via codice le due classi necessarie.
Andiamo, quindi, in “File -> New File…” e spostiamoci nella sezione “Cocoa Touch Class”, in cui selezioniamo il modello “UIViewController”: anche in questo caso dobbiamo creare due classi, chiamate “iPhoneDetailController” e “OtheDetailController”.

Possiamo spostare i file appena creati nella sezione “Classes” del nostro progetto, per avere un risultato come questo:

Ora siamo pronti per definire l’aspetto di queste due nuove viste.

4. Definiamo l’aspetto grafico delle due viste di dettaglio

Apriamo il file “iPhoneDetail.xib” in Interface Builder. Il procedimento è, come già detto, uguale a quello svolto per la definizione delle due viste “PrimaVista” e “SecondaVista”. Inseriamo, quindi, un componente UIView nel Pannello dei Documenti e modifichiamolo a nostro piacimento. Ecco come risulta essere la mia vista:

Ora associamo questa vista alla sua classe. Dal Pannello dei Documenti selezioniamo il “File’s Owner” e nell’”Identity Inspector” selezioniamo “iPhoneDetailController” come classe:

Andiamo poi in “Connections Inspector” e colleghiamo l’elemento “view” con la vista che abbiamo appena creato (quella contenente le due label per intenderci). Se abbiamo eseguito il passaggio in maniera corretta avremo questo risultato:

Abbiamo così completato la definizione della vista. Eseguiamo lo stesso procedimento anche per il file “OtherDetail.xib”, collegandola però alla classe “OtherDetailController”. Ecco come appare tale vista:

Possiamo salvare tutto e chiudere Interface Builder.

5. Come richiamare le due viste via codice

Ora non ci resta che analizzare il codice che ci permette di aprire queste due viste. Apriamo il file “TabellaController.h” e modifichiamolo nella seguente maniera:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#import <UIKit/UIKit.h>
#import "iPhoneDetailController.h"
#import "OtherDetailController.h"
 
@interface TabellaController : UITableViewController {
	//array che conterrà gli elementi da visualizzare nella tabella
	NSArray *lista;
 
	//controller della vista che dovrà essere aperta
	UIViewController *detail;
}
 
@property (nonatomic, retain) NSArray *lista;
 
@end

Abbiamo per prima cosa importato le due classi delle viste (righe 2 e 3), e poi definito una vista generica (riga 10), che poi inizializzeremo con la classe “iPhoneDetailController” oppure “OtherDetailController”, a seconda del caso. Perchè abbiamo utilizzato “UIViewController” come tipo dell’elemento “detail”? Perchè abbiamo sfruttato un paradigma della programmazione ad oggetti, che ci permette di definire un elemento con una superclasse, per poi inizializzarlo con una sottoclasse più specifica.

Ora apriamo il file “TabellaController.m” e inseriamo il metodo che viene richiamato quando si clicca su una cella:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// Metodo relativo alla selezione di una cella
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath {
 
	if (indexPath.row == 0){
		//l'utente ha cliccato sull'elemento iPhone, quindi carichiamo la vista relativa
		detail = [[iPhoneDetailController alloc] initWithNibName:@"iPhoneDetail" bundle:[NSBundle mainBundle]];
	} else {
		detail = [[OtherDetailController alloc] initWithNibName:@"OtherDetail" bundle:[NSBundle mainBundle]];
	}
 
	//Facciamo visualizzare la vista con i dettagli
	[self.navigationController pushViewController:detail animated:YES];
	//rilasciamo il controller
	[detail release];
 
	detail = nil;
}

Anche questo metodo lo avevamo già trovato nel tutorial dedicato alle tabelle. Analizziamo, però, il codice al suo interno. Troviamo inizialmente un ciclo if, che controlla se l’utente ha selezionato al prima cella, ovvero quella contenente l’elemento iPhone: se il controllo da esito positivo, inizializziamo l’elemento “detail” con la classe relativa alla vista “iPhoneDetail”, altrimenti con l’altra vista generica. La clausola “initWithNibName” si riferisce proprio al file xib che deve essere associato all’elemento “detail”.
Dopo il ciclo troviamo le istruzioni che ci permettono di far apparire la nuova vista; non preoccupatevi troppo, sono sempre queste istruzioni da utilizzare.

Abbiamo concluso!! Clicchiamo su “Build and Go!” e godiamoci la nostra applicazione funzionante!!

Se Avete Problemi, questo è il nostro file di progetto.

La guida è stata creata da Andrea Busi per “Bubi Devs”. I meriti, quindi, sono del legittimo autore.