Tra i primi articoli pubblicati ho introdotto il sistema operativo dell’iPhone e le sue tecnologie alle quali vi rimando per capire cosa rappresenta “Cocoa”:

Teoria: Il sistema operativo iPhone OS e la sua tecnologia: Core OS, Core Service, Media e Cocoa Touch: prima parte.

Teoria: Il sistema operativo iPhone OS e la sua tecnologia: schema livelli iPhone OS: seconda parte

Ora parleremo, prendendo spunto dal libro sopra citato, come e’ nato “cocoa”.

Un giorno, ormai tanto tempo fa, in un garage due signori dal nome in comune Steve costituiscono la societa’ Apple Computer. La societa’ cresce velocemente e viene nominato John Sculley quale CEO della compagnia.

Nascono i primi conflitti e John toglie i poteri di controllo della societa’ a Steve Jobs che poco dopo lascia la compagnia per costituire una nuova societa’ chiamata NEXT Computer.

NEXT era una società di brillanti ingegneri, era anni avanti in tecnologie di computer, il team di ingegneri sviluppo’ computer, sistema operativo, stampanti, e una serie di tools (strumenti) di sviluppo. Sfortunatamente la massa non capi le potenzialita’ e non vennero comprati abbastanza computer. La societa’ nel 1993 venne chiusa e da NEXT Computer divenne NEXT Software. Il sistema operativo insieme agli strumenti di sviluppo continuarono a essere venduti sotto NextSTEP.

NeXTSTEP

NeXT utilizzo il sistema operativo Unix. Unix perchè era un sistema affidabile, era un sistema molto più stabile di Windows della Microsoft o di Mac OS. Apple decise poi di far diventare Unix parte integrante del suo Mac OS X sotto il nome di Darwin (http://macosforge.org).

Ci furono molti sviluppi per NeXT con lo sviluppo di Window server per il sitema operativo, i PostScript di NeXTSTEP e CoreGraphics (conosciuto come Quarz) che venne scritto dagli sviluppatori per Mac OS X.

NeXTSTEP sviluppo’ tutta una serie di librerie e strumenti (tools) che aiutarono i programmatori a gestire in maniera elegante e in modo migliore le window server (window server era un sistema che prendeva e gestiva gli eventi che arrivavano dagli utenti e li portava alle applicazioni; le applicazioni ripondevano indietro con i comandi alle window server per aggiornare quello che vedeva l’utente). Tutte queste librerie vennero chiamate “Frameworks”. Nel 1993 queste librerie (frameworks) vennero riviste riaggiornate e cambiarono il nome prima in OpenStep e poi a finire Cocoa.

Per cercare di spiegarvi meglio in un sistema Unix, Cocoa abilita le applicazoni a ricevere gli eventi dalle window server e restituisce a video i risultati.

Spero quantomeno in questo articolo di avervi dato un minimo di spiegazione. Non volevo addentrarmi troppo nel tecnico, lo scopo forse più personale era quello di darmi una spiegazione di perchè Cocoa !… Non ho trovato però perchè e’ stato scelto questo nome …….

A voi… Sir Lodux !

iPhoneandGo.it - iphoneandgo@gmail.com

16) A questo punto, iniziamo la parte interattiva. Cocoa dispone di una gran mole di funzioni per interagire con l’interfaccia grafica. Tra le più interessanti c’è senza dubbio l’interazione con tastiera e mouse: non solo è possibile intercettare il clic del mouse, il doppio clic o il trascinamento – che è indispensabile per il famoso drag-and-drop – ma è anche possibile interpretare un tasto premuto sulla tastiera, o un tasto rilasciato, il che ricorda molto da vicino la pressione e il rilascio di un dito sulla tastiera di un iPhone! Ovviamente, non sono le stesse librerie, ma il concetto è lo stesso: intercettare l’input dell’utente (in gergo si chiama: interrupt) per permettere al software di “reagire” di conseguenza.

Vedremo ora come intercettare la pressione dei tasti freccia: Su, Giù, Sinistra e Destra.

Per fare questo, si utilizza l’oggetto: NSEvent, che si occupa appunto della gestione degli eventi.

Affinché la nostra NSView AreaDiGioco.m possa riconoscere e quindi interpretare un evento, è tuttavia fondamentale aggiungere due piccole ma importanti funzioni: prima di tutto bisogna che la nostra AreaDiGioco diventi sensibile, poi che accetti un input o un evento: – (BOOL)becomeFirstResponder e – (BOOL)acceptsFirstResponder sono le funzioni che servono in questo caso.

Una volta aggiunte queste due piccole funzioni, si crea la funzione – (void)keyDown:(NSEvent *)theEvent vera e propria, che si occuperà di valutare ed elaborare il risultato dell’inpur da tastiera:

17) Adesso compilate il programma (Command+R) e provate a cliccare sui tasti freccia. Il risultato dovrebbe essere simile a questo:

18) Semplice e meraviglioso, non trovate? A questo punto, facciamo in modo che premendo uno dei tasti freccia succeda qualcosa di più interessante! Alla pressione di uno dei tasti freccia, vogliamo che il riquadro corrispondente lampeggi in color magenta per poi tornare al colore originario.

Per fare questo, dobbiamo creare due diverse funzioni: la prima colorerà di magenta l’area corrispondente al pulsante premuto; la seconda, si occuperà di ridisegnare l’intera area della nostra finestra una volta rilasciato il tasto. Ma vediamo nel dettaglio come fare:

usando il vecchio e sempre caro copia e incolla (universalmente noto come il miglior metodo per evitare errori di battitura!), assegno ad ogni tasto premuto un’area, e la passo alla prima funzione che vado a creare: – (void)flash:(NSBezierPath * )flash che si occuperà di colorare l’area di magenta.

- (void)flash:(NSBezierPath *)flash {

[self lockFocus];

[[NSColor magentaColor] set];

;

[[NSGraphicsContext currentContext] flushGraphics];

[self unlockFocus];

}

Questa funzione utilizza un piccolo trucco, che potete leggere nel codice: prima di tutto, blocca l’area visualizzata; in secondo luogo disegna gli eventuali cambiamenti sopraggiunti; infine aggiorna il disegno della nostra NSView AreaDiGioco e sblocca la NSView lasciandola libera di ricevere nuovi input.

Questa procedura, che comincia con l’istruzione: [self lockFocus] e prosegue con: [[NSGraphicsContext currentContext] flushGraphics] per terninare con: [self unlockFocus] è valida universalmente, quando si tratta di disegnare con una NSView, perciò conoscerla è molto utile.

Una volta creata questa prima funzione, passiamo alla seconda: la funzione – (void)keyUp:(NSEvent *)theEvent. Molto simile alla funzione keyDown, questa funzione si occupa semplicemente di ridisegnare lo schermo com’era all’inizio. Anche qui, l’utilizzo del principio che comincia con [self lockFocus] è fondamentale.

6. Ottimizzazione

19) Come avrete notato, alcune parti di codice sono ripetute più volte nel file AreaDiGioco.m: in diversi punti ho dovuto ripetere le dimensioni delle quattro zone colorate (verde, blu, giallo, rosso), creando non pochi problemi di lettura del codice e di mantenimento dello stesso. Certo, questo è un semplice tutorial che prevede solamente un paio di file, ma è buona prassi ottimizzare il codice sia per evitare possibili errori (scrivendo due volte la stessa cosa, siete davvero sicuri di averla scritta sempre uguale?) sia per facilitare il debug e la comprensione del codice stesso. Per ottimizzare il codice di questo esempio, è necessario accorgersi che le quattro zone da colorare sono oggetti a se stanti (non preoccupatevi, con un po’ di pratica di programmazione OOP lo noterete subito), per cui è meglio, in questo caso, definire una volta sola queste quattro aree o NSBezierPath nel file AreaDiGioco.h, e richiamarle quando serve.

20) In questa maniera, le quattro aree che andremo a colorare e ad evidenziare premendo i tasti freccia saranno sempre a disposizione senza alcun bisogno di dover essere definite con più o meno complicate assegnazioni di NSRect eccetera. Basterà definirle una volta per tutte all’avvio del programma, nella funzione – (id)initWithFrame:(NSRect )frame, e saranno sempre con noi durante tutto l’utilizzo dell’applicazione.

MI RACCOMANDO!! Ricordatevi di trattenere queste variabili, una volta dichiarate! Se omettere il comando [retain] dopo averle dichiarate in: (id)initWithFrame:(NSRect)frame, non ne avrete alcun beneficio: il programma andrà in crash!! Quindi ricordatevi di ritenete le variabili che dichiarate all’init, mi raccomando.

21) In questo modo, tutto il codice sarà più pulito e leggibile. Un programmatore esperto sarebbe partito direttamente da questa considerazione e non avrebbe sperimentato altre soluzioni: per lui sarebbe stato ovvio considerare le diverse parti colorate dell’interfaccia come entità separate. Anzi, probabilmente le avrebbe instanziate come NSSubViews, ma qui le cose si complicano, per cui non ci avventureremo oltre, per il momento!…

22) In questo modo, il codice è davvero molto più pulito e leggibile.

23) Ed ecco il risultato finale:

7. Conclusione

24) Che dire? È stata una breve ma intensa passeggiata sui sentieri delle funzionalità di Cocoa! Spero che questo piccolo tutorial vi abbia fatto imparare qualcosa che ancora non sapevate, e scusate se per caso mi sono dilungato o sono stato mortalmente noioso. L’importante è una funzione che non conoscevate, un indizio, anche una sola parola vi sia stata utile. Certo, si potrebbe completare il tutorial con l’aggiunta di diversi suoni in corrispondenza dei diversi pulsanti premuti, oppure creare un meccanismo in grado di fare lampeggiare dei riquadri a caso e di interrogarvi per vedere se riuscite a ripeterli nell’ordine giusto, proprio come nel gioco!

Non sarebbe complicato, basterebbe un file con qualche istruzione, un NSTimer e magari un contatore che mostri sul display i diversi punteggi realizzati, ma il tempo è poco e non so se possa interessarvi più di tanto. Magari può essere lo spunto per una seconda parte del tutorial, chissà! L’importante è che vi siate divertiti a giocare con me, con Cocoa e con il vostro Mac. A presto!

Alessandro

iPhoneandgo - Stefano Lo Duca - loduca_ve@yahoo.it

Salve a tutti,

prima di cominciare mi sembra doveroso presentarmi: mi chiamo Alessandro e programmo su Macintosh da diversi anni, soprattutto in Cocoa e Applescript. Appena sono venuto a conoscenza dell’iniziativa di Stefano sul suo interessantissimo sito www.iphoneandgo.it, ho deciso di scrivere questo piccolo tutorial per esplorare alcune delle possibilità offerte dal framework di Cocoa, che Apple mette a disposizione gratuitamente per tutti coloro che vogliono cominciare o che già conoscono un linguaggio di programmazione e vogliono imparare a programmare in Objective-C.

Al momento in cui scrivo non dispongo, purtroppo (sob!), di un computer con Mac OS X Leopard e del relativo pacchetto di sviluppo per iPhone, ma pare che martedì prossimo Apple presenterà i suoi nuovi portatili, allora state certi che nel giro di qualche settimana avrò sia l’uno che l’altro!

In alternativa, ho deciso di scrivere qualche riga per mostrare ai neofiti (so benissimo quanto si abbia bisogno di esempi, quando si comincia!) come utilizzare alcune semplici librerie di Cocoa che riguardano l’input da tastiera, il disegno tramite NSView e in generale l’organizzazione necessaria per ottenere un codice pulito e facile da maneggiare. Credetemi: la bravura di un programmatore non sta solamente nella conoscenza che ha del suo linguaggio di programmazione preferito, sta soprattutto nell’ordine (del codice e mentale) con cui riesce a organizzare il software. Ma bando alle ciance!

1. Cominciamo!

Per cominciare, ho pensato a un vecchio gioco che mi ha sempre tanto divertito quanto annoiato: il vecchio Memo Colors. Sinceramente non so se si chiami davvero così: è quel gioco in cui un cerchio è diviso in quattro spicchi colorati che si illuminano e suonano in una certa sequenza, di solito sempre più lunga e difficile, che voi dovete ripetere senza errori. Divertente, ma un po’ noioso per me: non ricordo né un nome né un viso, ma una sequenza di suoni e colori mi basta vederla una volta e ripeterla è un gioco da ragazzi. Va be’, tagliamo!

1) Iniziamo con il creare il nostro progetto: per questo tutorial, andrà bene una semplice Cocoa Application. Dal menu File -> New Project e scegliete Cocoa Application.

2) Create il progetto e chiamatelo, per esempio, MemoColors. Il nome non è importante, ma è buona norma usare sempre le iniziali maiuscole, anche quando il nome è formato di più parole attaccate.

3) Dopo aver creato il progetto, dovreste vedere una finestra simile a questa:

4) Di default, XCode crea tutto quello di cui abbiamo bisogno per una normale applicazione: headers, collegamento alle principali librerie, interfaccia grafica. MemoColors è in rosso perché non è ancora stato compilato e quindi creato: questo è compito nostro! Se volete, potete già compilare il programma (Control+R) e vedere cosa succede. Il risultato non sarà dei più eccitanti, ma se non si verificano errori significa che tutto è a posto e possiamo cominciare ad aggiungere il nostro codice. Allora cominciamo!

2. NSView

5) Dato che il nostro programma dovrà disegnare, anche se in forma grossolana, le quattro aree colorate che ricordano il gioco, dobbiamo aggiungere al progetto un nuovo file, che si occuperà esclusivamente del disegno. Andiamo su File -> New File… e scegliamo Objective-C NSView subclass.

6) Ho chiamato questo file AreaDiGioco, ma potete dargli un nome qualunque. L’importante è che per voi sia chiaro che questo file (e il suo nome dovrebbe suggerirlo) si occuperà di disegnare e aggiornare quanto visivamente apparirà lanciando il programma.

7) Una volta creato, questo file apparirà così:

3. Preliminari

Come abbiamo detto, questo file si occuperà di disegnare ciò che vedremo una volta lanciata l’applicazione. Per poter utilizzare questo file, però, dobbiamo prima integrarlo con Interface Builder. Per fare questo apriamo Interface Builder, prendiamo il file AreaDiGioco.h dall’elenco dei file di XCode, e trasciniamolo sulla finestra MainMenu.nib. Il file a questo punto è stato accettato dall’interfaccia ed è disponibile per ogni successiva manipolazione:

9) Perfetto! Quello che vogliamo ora, è che il programma utilizzi, una volta lanciato, una NSView, o meglio la “nostra” NSView, per mostrare ciò che succede sullo schermo. Per fare questo, bisogna per prima cosa aggiungere alla finestra principale una vista generica, e poi specificare che si tratta della “nostra” vista, ossia che il comportamento della vista verrà gestito dal file AreaDiGioco che abbiamo creato in XCode:

10) Adattate la finestra e la CustomView in modo che combacino (ho scelto le dimensioni 320×480, come lo schermo del Melafonino) e assegnate alla CustomView (che non è altro che una vista generica) la tipologia corretta, ossia la nostra AreaDiGioco:

11) A questo punto torniamo in XCode, e andiamo a modificare il codice in modo che l’intera area visualizzata venga colorata di grigio. Non è molto allegro, ma almeno saremo sicuri che tutto sta funzionando nella maniera corretta:

12) A questo punto compiliamo il programma. Dovrebbe apparire una finestra completamente grigia, come questa:

4. Aggiungiamo i colori

13) Bene, siamo sulla buona strada! Adesso, andiamo a creare la funzione che mostrerà le quattro aree con i quattro diversi colori scelti. La funzione è molto semplice: prima crea un rettangolo (NSRect), poi un’area basata su quel rettangolo (NSBezierPath), infine imposta un colore e lo applica all’area. Molto semplice. Il nome che ho usato per la funzione è: mostraAreeColorate, o meglio – (void)mostraAreeColorate. La funzione non restituisce alcun valore (void, infatti) perché non ci interessa avere un riscontro, l’importante è che faccia quello che deve. Cominciamo con un colore alla volta: come prima cosa, proviamo a colorare di verde il riquadro in basso a sinistra.

Dato che l’altezza e la larghezza della finestra della nostra applicazione non cambieranno, è conveniente definirli come costanti. Alla riga 11 del codice di AreaDiGioco.m vengono infatti definite le costanti ALTEZZA e LARGHEZZA, che ci serviranno per tutto il tutorial.

Una volta definite altezza e larghezza, creiamo il rettangolo che useremo come base per definire un’area, scegliamo il colore verde [NSColor greenColor] e lo usiamo per riempire l’area appena definita. Facile, no?

PS: Se non avete definito la funzione – (void)mostraAreeColorate anche nell’header del file, ossia: AreaDiGioco.h, il compilatore vi segnalerà un warning (riga 35). Non è importante, ma è meglio evitare queste piccole imprecisioni quando si andrà in fase di release vera e propria.

14) Una volta definito il primo riquadro colorato, procediamo nello stesso modo per gli altri tre. Il codice risultante sarà questo:

15) L’utilizzo dei commenti dovrebbe essere limitato in fase di release, ma per testare il codice non solo è molto utile: è decisamente indispensabile! A questo punto, lanciate la vostra applicazione. Il risultato finale dovrebbe essere molto simile a questo. Certo, non sarà la Gioconda, ma con appena 16 righe di codice è un ottimo risultato!

Parte 2a

iPhoneandGo - Stefano Lo Duca - loduca_ve@yahoo.it

Partiamo dal livello più alto quello più importante e pratico :

Cocoa Touch

• UIKit.framework
• Foundation.framework

Media

• Grafica:
  • OpenGLES.framework
  • EAGL.framework
  • QuartzCore.framework
  • Core-Graphics.framework
• Core Audio
  • CoreAudio.framework
  • AudioToolbox.framework
  • AudioUnit.framework
  • OpenAL -> Open Audio Library
• Video
  • MediaPlayer.framework

Core Services

• Address book
  • AddressBook.framework
  • AddressBookUI.framework
• Core Foundation
  • CoreFoundation.framework
• Core Location
  • CoreLocation.framework
• CFNetwork
  • CFNetwork.framework
• Security
  • Security.framework
• SQLite
  • SQLite Library
• XML
  • limXML2
  • libxslt

Core OS

• LibSystem library

Questo schema riassume tutti gli strumenti che ci vengono messi a disposizione per creare le nostre applicazioni per iPhone. Vedremo di analizzarle una per una con prove pratiche e spiegazioni fin dai prossimi articoli.

iPhoneandGo – Stefano Lo Duca – loduca_ve@yahoo.it

Il sistema operativo iPhone OS e’ il software (il cuore) che sta alla base del nostro iphone che gestisce praticamente tutto tra il nostro applicativo e cio’ che l’iphone deve fare per noi come ad esempio mettere a disposizioni le risorse hardware.

Per poter programmare scegliendo gli strumenti più giusti per sviluppare i nostri applicativi, dobbiamo immaginarci un sistema operativo suddiviso a 4 livelli.

iPhone OS Technologies

Core OS si trova nel livello più basso e rappresenta le funzioni più primitive, le operazioni più vicine al cuore del sistema (e solitamente quindi le più complesse). Core OS gestisce l’allocazione di Memoria, informazioni locali, sistema di input e output, il networking, l’accesso ai file di sistema, i drivers, i servizi DNS. Si può accedere alle sue funzioni tramite la libreria LibSystem.

Core Services rappresenta tutti i servizi fondamentali che le applicazioni necessitano di gestire, come Address Book (la gestione dei contatti), come il supporto e la gestione dei : tipi di dati (arrays, sets, ecc), delle date dell’ora delle stringhe, delle preferenze di sistema, degli url, ecc. più avanti illustrero’ con uno schema tutti i servizi. Inoltre gestisce i servizi di localizzazione: longitudine e latitudine, gestisce il CFNetwork.framework, Security.Framework, le libreria SQLite per la gestione di un DataBase eil supporto al XML.

Media tutto quello che rappresenta la grafica, media, audio, video viene gestito qui. Quelle che sono le migliori esperienze multimediali che l’iphone dispone sono gestite da questi framework.

Cocoa Touch è il livello più importante del sistema iphone. Viene gestito da due framework UIKit e Foundation Frameworks. Questi frameworks gestiscono aspetti molto importanti come : la gestione delle applicazioni, della grafica e della gestione delle finestre, degli eventi, dell’interfaccia, degli oggetti che controllano il sistema, e il supporto per i contenuti testuali e web. Inoltre gestiscono l’accelerometro, la libreria fotografica, la fotocamera, e le informazioni sul device.

Nel prossimo articolo cercherò con uno schema di riassumere le diverse funzionalità e framework esistenti nei vari livelli del nostro iphone OS.

iPhoneAndGo – Stefano Lo Duca – loduca_ve@yahoo.it