Oggi parliamo di iAD e come implementarlo all’interno delle nostre applicazioni. iAD permette di mostrare contenuti pubblicitari direttamente dall’interno della nostra applicazione. Verremo pagati in base a quante visualizzazioni (e click) facciamo attraverso la nostra applicazione.

Apple si occupa di vendere la pubblicità e fornire al programmatore che implementa iAD i corrispettivi di guadagno in base ai criteri di cui sopra.

Non mi dilungherò ancora sulle caratteristiche del network iAD e sulle sue potenzialità, esistono già abbastanza articoli presenti su DevAPP in merito.

Per implementare con successo iAD è necessario tenere presente quattro concetti base:

• I banner sfruttano una porzione dello schermo. Bisognerà adattare il nostro schermo alla presenza o meno di pubblicità. Attenzione al fatto che Apple prevede la possibilità che non ci siano banners pubblicitari per un determinato lasso temporale o per una determinata nazione. In questi casi, la nostra applicazione dovrà continuare a funzionare EVITANDO di lasciare sullo schermo una zona BIANCA (o vuota) in cui dovrebbe andare la pubblicità. Se non implementata correttamente questa caratteristica, potrete incorrere in un reject da parte di Apple per non conformità alla UIGL.
• Prevedere (dove necessario) una pausa di tutte le attività con criticità di tempo quando l’utente visualizza una pubblicità. Immaginate di stare sviluppando un game, in cui volete aggiungere della pubblicità come fonte di reddito. In questo caso, sarà opportuno, prevedere uno o più metodi, preposti alla messa in pausa delle funzionalità base del nostra applicazione (nel caso di un game: scrolling, animazioni, tempo, etc.). Sarà compito dei delegati della classe che adotta il protocollo ADBannerViewDelegate, invocarli al momento opportuno.
• Riattivare tutte le attività con criticità di tempo dopo che l’utente ha chiuso la pubblicità. Anche in questo caso, sarà compito della nostra classe che adotta il protocollo ADBannerViewDelegate, invocare i metodi opportuni alla chiusura dello spot pubblicitario.
• Filtrare pubblicità concorrenziali con la nostra applicazione (facoltativo).

Operazioni preliminari

Ai fini del programmatore, iAD è composta da un oggetto che eredita da UIView (ADBannerView) e da un delegato (ADBannerViewDelegate).

Quindi, dovunque possiamo inserire un oggetto UIView (ed implementare il suo delegato), possiamo utilizzare iAD. Questo include (ma non è limitato soltanto) gli UIViewController ed UITableViewController. Nel nostro esempio, utilizzeremo un oggetto UIViewController.

I preliminari

Per prima cosa, bisogna aggiungere il supporto ad iAD nella nostra applicazione. Per fare questo è necessario appoggiarsi ad un framework di Apple preesistente. Selezioniamo la cartella Frameworks dalla lista dei files nel nostro progetto e, premendo con il tasto destro, scegliamo di aggiungere un framework preesistente:

A questo punto, selezioniamo la voce iAD.framework e premiamo Add.

Ricordiamoci di aggiungere il supporto al framework nel nostro file .pch:

#ifndef __IPHONE_3_0
#warning "This project uses features only available in iPhone SDK 3.0 and later."
#endif

#ifdef __OBJC__
    #import 
    #import 
	#import 
#endif

iAD ed interazione con i viewControllers

Creiamo una nuova classe di tipo UIViewController ed adottiamo il protocollo ADBannerViewDelegate:

@class ADBannerView;

@interface MainViewController : UIViewController  {

	ADBannerView *_adBannerView;

	UIView *contentView;
	UILabel *timerLabel;
	NSTimer *myScheduler;
	unsigned long myTimerCounter;
}

- (ADBannerView *)createAdBannerView;
- (void)showHideAdView:(int)operationType;

@end

Al suo interno, avremo cura di dichiarare una variabile d’istanza puntatore ad un oggetto di tipo ADBannerView. Le altre variabili serviranno rispettivamente per creare una view contenitore (UIView), creare una casella di testo in cui aggiungeremo un contatore di secondi (UILabel) ed un timer (NSTimer) utile per scandire il refresh del nostro timer a schermo.

Spostiamoci nella parte di implementazione ed implementiamo il metodo di loadView. Come sappiamo, esso verrà invocato ogni qualvolta ci sarà necessità di disegnare la UIView del nostro controllore a schermo.

- (void)loadView {
	contentView = [[UIView alloc] initWithFrame:[[UIScreen mainScreen] applicationFrame]];
	[contentView setBackgroundColor:[UIColor redColor]];
	
	timerLabel = [[UILabel alloc] initWithFrame:CGRectMake(0, 140, 320, 20)];
	[timerLabel setBackgroundColor:[UIColor clearColor]];
	[timerLabel setFont:[UIFont systemFontOfSize:18]];
	[timerLabel setTextAlignment:UITextAlignmentCenter];
	[timerLabel setTextColor:[UIColor blackColor]];
	
	[contentView addSubview:timerLabel];
	[timerLabel release];
	
	myScheduler = [NSTimer scheduledTimerWithTimeInterval:1.0 target:self selector:@selector(incrementTimer) userInfo:nil repeats:YES];
	
	self.view = contentView;
	[contentView release];
}

La prima cosa da fare è quella di creare un oggetto UIView contenitore che sarà assegnato alla property view del nostro controllore. Al suo interno trova posto anche l’oggetto timerLabel, necessario per mostrare a schermo il nostro timer.

L’oggetto myScheduler, di tipo NSTimer, è molto interessante. Se non vi siete mai imbattuti in esso, vi consiglio vivamente di leggere un pò della documentazione Apple a riguardo. Esso è un ottimo compromesso ai Thread, quando è possibile applicarlo.

Nel nostro caso specifico lo utilizzeremo come schedulatore del passare dei secondi. Quello che facciamo è crearne un’istanza autorilasciante, grazie all’invocazione del metodo di classe scheduledTimerWithTimeInterval:target:selector:userInfo:repeats.

Ad esso passiamo il tempo di scadenza per ogni successiva invocazione, la classe target idonea a ricevere l’evento, il selettore da invocare nell’evento, eventuali payloads aggiuntivi e la modalità di ripetizione.

Notate come la variabile sia dichiarata d’istanza, quindi, è lecito dedurre che essa sarà valida per tutto il tempo di durata del timer. Nel nostro caso specifico, essa resterà valida sino a quando non interromperemo (invalidate) il timer esplicitamente, visto che abbiamo selezionato la modalità repeat.

Alla fine, assegniamo il contenuto della UIView contenitore alla property view del nostro UIViewController e rilasciamo la sua istanza.

I metodi delegati, invocati subito prima e subito dopo la visualizzazione della view, completano l’inizializzazione del nostro controllore.

- (void)viewWillAppear:(BOOL)animated {
	myTimerCounter = 0;
}

- (void)viewDidAppear:(BOOL)animated {
	_adBannerView = [self createAdBannerView];
	[contentView addSubview:_adBannerView];
}

Poco prima della visualizzazione del contenuto del metodo loadView, provvederemo a resettare il nostro contatore dei secondi e, subito dopo la visualizzazione della view, provvederemo ad istanziare il nostro oggetto ADBannerView.

Per farlo, invochiamo un metodo createAdBannerView responsabile della creazione e restituizione di una istanza valida di tipo ADBannerView; vedremo nel prossimo paragrafo di cosa si tratta. Ai fini del metodo viewDidAppear, ci basta sapere che l’istanza ritornata eredita da UIView, quindi possiamo operare con essa come in presenza di una normale UIView. Infatti, al ritorno dalla funzione di creazione, aggiungiamo la view risultante al nostro contentView.

La creazione del nostro banner pubblicitario è responsabilità del metodo createAdBannerView:

- (ADBannerView *)createAdBannerView {
	ADBannerView *myBannerView = [[ADBannerView alloc] initWithFrame:CGRectZero];
	[myBannerView setRequiredContentSizeIdentifiers:[NSSet setWithObjects:
													 ADBannerContentSizeIdentifierPortrait, nil]];
	[myBannerView setCurrentContentSizeIdentifier:ADBannerContentSizeIdentifierPortrait];            
	[myBannerView setDelegate:self];
	[myBannerView setAlpha:0.0];
	[myBannerView setCenter:CGPointMake(160, 500)];
	return [myBannerView autorelease];    
}

Come prima cosa, dobbiamo allocare ed inizializzare un’istanza di tipo ADBannerView. Su quest’ultima, aggiungiamo tutti i tipi di banner che vogliamo supportare. Attualmente esistono due tipo di banner: uno per l’orientamento verticale del nostro dispositivo, ed una per l’orientamento orizzontale. Nel nostro esempio, popoleremo l’oggetto NSSet con la sola modalità Portrait, visto che la nostra applicazione non supporta le altre modalità.

Subito dopo, assegnamo come delegato la classe UIViewController stessa e ci preoccupiamo di rendere invisibile (setAlpha) e mettere fuori dallo schermo (setCenter) l’istanza di ADBannerView che, ricordo ancora una volta, è una classe che eredita direttamente dalla classe UIView.

Dopo la configurazione ritorniamo l’oggetto appena istanziato. Prima di farlo, però, è necessario lanciare un messaggio di autorelease, prima della restituzione, per evitare un problema di rilascio anticipato della memoria.

La claase ADBannerView

La classe ADBannerView è responsabile di creare una view che mostri contenuti pubblicitari all’interno della nostra applicazione. L’oggetto eredita direttamente da UIView. Ad esso, quindi, si applicano tutte le proprietà e le caratteristiche degli oggetti di tipo UIView (che dovremmo conoscere molto bene).

A questo oggetto è associato un delegato, responsabile della corretta visualizzazione a schermo degli spot pubblicitari associati ad un banner. Il delegato viene invocato ogni qualvolta si clicca su di un banner.

La classe delegata deve anche essere responsabile della corretta gestione dei banners a schermo in caso di mancanza di connessione internet o nel caso in cui Apple decida di non trasmettere momentaneamente dei banners pubblicitari (ad esempio, in particolari nazioni, iAD non è disponibile).

Iniziamo subito con il costruire un metodo che, quando invocato, mostra a schermo (o nasconde) la nostra istanza di ADBannerView creata sopra. In questo modo, se ci sono dei messaggi pubblicitari disponibili, li mostreremo a schermo. Nel caso di non disponibilità, eviteremo di lasciare una zona inutilizzata e non reattiva a schermo.

- (void)showHideAdView:(int)operationType {
    if (_adBannerView != nil) {        
		[_adBannerView setCurrentContentSizeIdentifier:ADBannerContentSizeIdentifierPortrait];
		
		[UIView beginAnimations:@"showHideAdView" context:nil];
		switch (operationType) {
			case hideiADBanner:
				[_adBannerView setCenter:CGPointMake(160, 500)];
				[_adBannerView setAlpha:0.0];
				break;
			case showiADBanner:
				[_adBannerView setCenter:CGPointMake(160, 460-25)];
				[_adBannerView setAlpha:1.0];
			default:
				break;
		}
        [UIView commitAnimations];
    }   
}

Il metodo prende come input un parametro di tipo intero che può assumere due valori: showADBanner e hideADBanner.

typedef enum iADShowerSwitch { 
	showiADBanner = 0,
	hideiADBanner = 1
} iADShowerSwitch;

Nel caso in cui la nostra applicazione dovrà gestire più orientamenti, sarà in questo metodo che sceglieremo come mostrare a schermo il banner. A seconda (switch) dell’operazione desiderata, mostriamo o nascondiamo a schermo l’oggetto ADBannerView. L’operazione è stata racchiusa all’interno di un brachet begin/commitAnimations, per ottenere un gradevole effetto animato durante la visualizzazione/sparizione dallo schermo.

La User Interface Guide Lines di Apple, consiglia caldamente di gestire entrambe le evenienze (presenza o meno di eventuali banners pubblicitari). Per fare questo, è necessario implementare nella classe che adotta il protocollo ADBannerViewDelegate due metodi. Il primo si occupa di mostrare a schermo gli eventuali banners pubblicitari inviati dal server di Apple:

– (void)bannerViewDidLoadAd:(ADBannerView *)banner {
[self showHideAdView:showADBanner];
}

Il secondo si occupa di nascondere l’eventuale banner presente a schermo, in caso di errore o mancata comunicazione con il server Apple.

- (void)bannerView:(ADBannerView *)banner didFailToReceiveAdWithError:(NSError *)error {
	NSLog(@"ADBannerView ERROR: %@", [error localizedDescription]);
	[self showHideAdView:hideiADBanner];
}

Ci resta da implementare i due metodi delegati responsabili per la gestione a schermo dello spot pubblicitario in caso di pressione sul banner da parte dell’utente. Come anticipato all’inizio di quest’articolo, sarebbe desiderabile interrompere qualunque operazione time critical, all’interno della nostra applicazione, durante la visualizzazione della pubblicità. Essa, infatti, occupa momentaneamente tutto lo schermo dell’iPhone/iPad.

Nel nostro esempio, quello che faremo sarà sospendere e riattivare il nostro timer a schermo alla visualizzazione/scomparsa della pubblicità. Ovviamente, un metodo completo dovrebbe prendere in considerazione tutte le parti critiche dell’applicazione.

Al completamento delle operazioni di sospensione dell’applicazione, ricordiamoci di ritornare con un valore booleano positivo. In caso negativo, infatti, la pubblicità non verrà mostrata a schermo.

- (BOOL)bannerViewActionShouldBegin:(ADBannerView *)banner willLeaveApplication:(BOOL)willLeave {
	[self pauseTimer];
	return YES;	
}

Al ritorno dalla pubblicità, effettuiamo l’operazione inversa: riattiviamo il timer e riprendiamo la normale attività della nostra applicazione.

- (void)bannerViewActionDidFinish:(ADBannerView *)banner {
	[self restartTimer];
}

Ci restano da implementare i quattro metodi ausiliari, necessari per incrementare, sospendere, riattivare e mostrare a schermo il nostro contatore.

- (void)renderTimerToScreen {
	[timerLabel setText:[NSString stringWithFormat:@"seconds elapsed: %d", myTimerCounter]];
}

- (void)incrementTimer {
	myTimerCounter++;
	[self renderTimerToScreen];
}

- (void)restartTimer {
	myScheduler = [NSTimer scheduledTimerWithTimeInterval:1.0 
                                          target:self 
                                          selector:@selector(incrementTimer) 
                                          userInfo:nil 
                                          repeats:YES];
}

- (void)pauseTimer {
 	[myScheduler invalidate];
}

iAD e configurazione su iTunesConnect

Attenzione, questo paragrafo non è strettamente necessario per la fase di testing. In base alle mie esperienze, per testare con un provisioning profile di debug/release su iPhone o Simulatore quanto sopra riportato, non è necessario provedere con la creazione di un’applicazione abilitata ad iAD. Tuttavia, quest’operazione è necessaria nel caso in cui si decida di sottomettere l’applicazione ad Apple per la revisione, utilizzando il sistema pubblicitario iAD. Apple consiglia sempre di creare preventivamente e nella fase di testing un provisioning profile (ed una relativa applicazione su iTunesConnect) legato all’applicazione che si sta sviluppando.

Per fare questo, apriamo il portale iTunesConnect e creiamo un’applicazione legata al provisioning profile scelto in fase di sviluppo. Non ha importanza se poi non pubblicherete quest’applicazione. Potrete sempre rimuovere l’applicazione da iTunesConnect quando lo desiderate.

Una volta creata l’applicazione, selezionatela e scegliete il menu Setup iAD Network.

Il sistema vi chiederà che genere di target avete in mente per la vostra applicazione e se esso è di tipo minorenne. Effettuate la vostra scelta e premete Enable iADs.

A questo punto, il portale vi risponderà, ricordandovi che l’abilitazione ad iAD avverrà solo alla prossima revisione, da parte di Apple, dell’applicativo:

Un’ultima cosa

C’e’ ancora un’ultima cosa di cui ritengo sia utile parlare. Dalla homepage del vostro portale iTunesConnect, c’è la possibilità di gestire e visualizzare l’andamento della propria pubblicità, all’interno delle singole apps:

Attraverso questo frontend, sarà possibile visualizzare gli andamenti ed i guadagni dalla pubblicità, così come sarà possibile gestire eventuali gruppi di pubblicità selezionate per parole chiave che non si vuole appaiano all’interno della nostra applicazione (ad esempio, applicazioni concorrenti).

Il sistema è egregiamente documentato e semplice da usare. Vi invito a navigarlo e studiarlo, insieme alla documentazione Apple sull’argomento.

Grazie e buona programmazione a tutti!
Costantino

Se avete problemi con il tutorial, questo è il nostro file di progetto.