Sei sulla pagina 1di 45

Facolt di Ingegneria

Corso di Laurea: Ingegneria delle Comunicacazioni

Cattedra: Tecniche Audiovisive

Titolo: Android: utilizzo del GPS e dellaccelerometro

Studente: Riccardo Russo Matricola: 1044117 Anno accademico 2010/2011

Sommario
Android: ............................................................................................................................................................. 3 Storia di Android ................................................................................................................................................ 7 Evoluzione di Android:..................................................................................................................................... 10 Android 1.0 e 1.1 ..................................................................................................................................... 10 Android 1.5 : Cupcake (minitorta) ........................................................................................................... 10 Android 1.6 : Donut (ciambella) .............................................................................................................. 11 Android 2.0 : clair (Pasticcino) ............................................................................................................... 11 Android 2.1 clair (Pasticcino) & 2.1 Update 1 (Multi-touch) ................................................................. 12 Android 2.2 : Froyo (Frozen Yogurt, Yogurt Gelato) ................................................................................ 12 Android 2.3 Gingerbread (Pan di Zenzero) .............................................................................................. 13 Android 2.4 IceCream (gelato) ................................................................................................................ 14 Android 3.0 Honeycomb (Nido) ............................................................................................................... 14 Android 4 Ice Cream Sandwich (gelato al biscotto)................................................................................ 15 Creare lambiente di sviluppo ......................................................................................................................... 16 Architettura di Android ................................................................................................................................... 22 Componenti di una applicazione Android ....................................................................................................... 26 Activity ......................................................................................................................................................... 26 Content Provider ......................................................................................................................................... 26 Broadcast Receiver ...................................................................................................................................... 27 Service ......................................................................................................................................................... 27 Gestione dei componenti ............................................................................................................................ 28 Struttura di un progetto Android .................................................................................................................... 31 Significato e contenuto dei file principali .................................................................................................... 33 Descrizione dellapplicazione TesinaTecAudio ............................................................................................ 36 Descrizione del package android.location ................................................................................................... 36 Ottenere la posizione del dispositivo ...................................................................................................... 37 Descrizione del package android.hardware ................................................................................................ 38 Ottenere i dati relativi al sensore ............................................................................................................ 39 File sorgenti dellapplicazione TesinaTecAudio ....................................................................................... 40 Sitorgrafia: ....................................................................................................................................................... 45 Bibliografia:...................................................................................................................................................... 45

Android:
Android un sistema operativo open source per dispositivi mobili basato sul kernel 2.6 di Linux. A livello tecnico, la piattaforma open source Android di fatto uno stack, ovvero un set di sottosistemi software, basato sul kernel Linux e che composto da applicazioni Java che vengono eseguite su uno speciale frame work. Questultimo anch'esso basato su Java e orientato agli oggetti, a sua volta eseguito su un nucleo costituito da librerie Java eseguite tramite la macchina virtuale Dalvik, specifica per dispositivi mobili, dotata di compilatore just-in-time (JIT). Diversi sono i componenti che compongono le librerie, sviluppate in linguaggio C: un surface manager, un framework multimediale OpenCore, un sistema a database relazionali SQLite, API grafiche 3D OpenGL ES 2.0, un motore grafico e di layout basato su WebKit, un motore grafico SGL, SSL ed una libreria libc Bionic, libreria standard per C basata in gran parte su BSD. In sintesi, come spiegano i "testi sacri" sull'argomento, il sistema operativo Android composto in tutto da 12 milioni di righe di codice che comprendono 3 milioni di righe di XML, 2,8 milioni di righe di C, 2,1 milioni di righe di Java e 1,75 milioni di righe di C++. Dallottobre 2008, data di rilascio della prima versione Android, lo sviluppo e la diffusione di tale sistema operativo stata inesorabile a tal punto da renderlo oggi il sistema pi utilizzato. Una recente indagine della Nielsen, infatti, mostra come Android sia il sistema operativo maggiormente diffuso (Figura 1) e come oltre il 50% degli smartphone acquistati di recente sia un dispositivo Android (Figura 2).

Figura 1: diffusione dei vari sistemi operativi

Figura 2: tipologie di smartphone acquistati di recente

Ad un fenomeno di tali proporzioni, chiaramente, si affiancato un vasto numero di community e siti di sviluppatori Android o semplici utilizzatori di applicazioni. Questultimi possono reperire le varie applicazioni nell Android Marcket ossia un contenitore di software online sviluppato da Google per i dispositivi Android. Ci avviene tramite lutilizzo di un applicativo chiamato "Market", preinstallato sulla maggior parte dei dispositivi Android, che permette agli utenti di cercare e scaricare le applicazioni pubblicate da sviluppatori di terze-parti e ospitate sull'Android Market. In alternativa possibili scaricare le applicazioni tramite pc dal sito https://market.android.com e poi installarle sul proprio dispositivo. Attualmente lAndroid Marcket conta pi di 500.000 applicazioni di cui una grande parte costituita dai giochi, anche lutilit e la complessit varia notevolmente. Si pu passare da applicazioni che sfruttano i vari sensori e funzioni del dispositivo come il GPS, laccelerometro, bussola elettroniche, la fotocamera, il microfono, ecc.. a semplici applicazioni che si limitano a fungere da contenitori di informazioni ed immagini. Numerose sono le categorie di applicazioni disponibili sulAndroid Marcket: musica, intrattenimento, lavoro, giochi, salute, sfondi e molti altri ancora. Sostanzialmente esiste un applicazione per ogni esigenza. Al fine di comprendere meglio la reale utilit e complessit di suddette applicazioni vengono di seguito descritte alcune di queste. Nel settore dei trasporti, ad esempio, esistono applicazioni come Roma bus che, sfruttando la connessione ad internet, si interfaccia con i sistemi dellAtac riuscendo cos a fornire informazioni in tempo reale sugli orari e tempi di attesa dei vari autobus. Applicazioni analoghe sono disponibili sia per altre citt sia per altri mezzi di trasporto come Metro, treni ed aerei. Tra gli automobilisti, invece, sono molto gettonati gli applicativi capaci di segnalare i vari autovelox fissi e mobili e la presenza di tratte autostradali in cui attivo il sistema Tutor fornendo anche la velocit media dellautovettura nella tratta di interesse. Nel campo della medicina invece possibili trovare veri e propri manuali su patologie, medicinali o tecniche di primo soccorso. In tali casi, le applicazioni risultano esser semplici contenitori di informazioni, come accennato prima. Ambizioni ben diverse caratterizzano, invece, uno studio di alcuni ricercatori 4

dellImec e dellHolst Centre, i quali, insiemi ad alcuni professionisti del software TASS hanno progettato un sistema mobile di monitoraggio del cuore che permette di visualizzare il proprio elettrocardiogramma sul proprio dispositivo Android. Il sistema costituito da una collana di sensori miniaturizzati detta Body Area Network (BAN) che, collegata ad un telefono cellulare, permette un affidabile e prolungato monitoraggio di diversi parametri vitali come il battito cardiaco, lattivit celebrale, lattivit muscolare, ecc

Figura 3: esempio di funzionamento del sistema mobile di monitoraggio

I dati raccolti dalla BAN vengono dunque memorizzati, elaborati e inviati su internet per renderli fruibili agli utenti autorizzati come ad esempio il proprio medico. Un ulteriore vantaggio di tale sistema la possibilit di poter integrare le varie funzioni disponibili sul sistema operativo di Google come linvio di SMS, trasmissione e-mail o lutilizzo del GPS per individuare la posizione dell'utente qualora vengano misurati valori anomali dei vari parametri monitorati. Nel suo complesso, lintero sistema offre un duplice vantaggio: una diminuzione dei costi dellassistenza sanitaria, poich il paziente non costretto a restare in ospedale e, allo stesso tempo, una pi confortevole degenza per il paziente stesso. Altro settore in cui Android potrebbe trovare grande sviluppo la domotica. Google, per tale settore, ha presenato un intero framewok dal nome Androi@Home. Nel campo della ricerca scientifica-didattica potrebbe rivelarsi molto utile scaricare lapplicazione IOIO Manager la quale consente di gestire una scheda IOIO. Questultima una scheda progettata per lavorare in abbinamento ad un dispositivo (palmare, tablet, pc ecc) funzionante con sistema operativo Android (dalla versione 1.5 in su). La scheda viene collegata al dispositivo Android mediante USB. IOIO interamente pilotabile dalle applicazioni Android utilizzando delle API scritte in Java semplici ed intuitive. Non necessario un programmatore esterno ne saper programmare per dispositivi embedded, nemmeno per l'aggiornamento del firmware. IOIO basato su una singola MCU programmata per funzionare come host USB ed interpreta i comandi ricevuti dalle applicazioni scritte per utilizzarlo. In aggiunta IOIO pu interfacciarsi a varie periferiche allo stesso modo in cui si interfaccia una MCU. Periferiche come I/O digitali, ingressi analogici, PWM, I2C, SPI e UART. In altre parole: possibile combinare la grande potenza di calcolo offerta dal vostro dispositivo Android, la connettivit Internet/Bluetooth, il Touch Screen e tutti i sensori con tutte le periferiche esterne collegabili a IOIO. 5

Figura 4 IOIO per Android

Unaltra applicazione potenzialmente utile al settore tecnico-sientifico derivata dallo sviluppo dei videogiochi Gremote la quale permette di controllare il pc tramite smartphone, il quale pu dunque fungere da mouse, tastiera o joystick. Nel settore dei beni culturali, invece, anche se tecnicamente possibile non ancora disponibile per Android una applicazione simile a iMiBAC Voyager. Questultima unapplicazione gratuita che ricostruisce virtualmente, in 3D ed in tempo reale, il Foro Romano in et costantiniana mentre si passeggia allinterno dellarea archeologica. Nello specifico, iMiBAC Voyager utilizza il GPS, la bussola elettronica e gli accelerometri dei terminali iPhone/iPad, per riconoscere la posizione ed il punto di vista dellutente, consentendo una navigazione molto semplice ed intuitiva. Basta solamente puntare liPhone o liPad verso un monumento per godersi un esperienza immersiva unica. Utilizzando un algoritmo software, infatti, lapplicazione in grado di riconoscere qualsiasi monumento georeferenziato intorno alla posizione dellutente e grazie a questa tecnica possibile ascoltare laudioguida in diverse lingue, la quale fornisce tutte le informazioni storiche su di esso. Questi pochi esempi mostrano come applicazioni anche molto diverse tra loro, di fatto, altro non sono che una diversa combinazioni di utilizzo dei vari sensori del dispositivo. Il grande vantaggio di Android intrinsecamente racchiuso nella sua stessa natura, ossia nel fatto di essere estremamente compatibile ed interfacciabili con tutti gli altri servizi offerti da casa Google. In tal senso, una semplice applicazione che sfrutti le funzionalit GPS, diventa immediatamente pi performante e piacevole da utilizzare quando viene fatta interagire con le mappe proprietarie di Google.

Storia di Android

Dietro quello che sembra lennesimo successo della societ di Mountain View, troviamo Andy Rubin e la sua idea: make a device about the size of a small candy bar that cost less than $10 and allowed users to scan objects and unearth information about them on the Internet. cio quella di realizzare un device di dimensioni contenute e dal costo irrisorio che permetta agli utenti di scannerizzare (fotografare) oggetti ed ottenere informazioni su di essi attraverso internet. Siamo nel 1999 e la telefonia non assolutamente una componente prevista per il dispositivo di Rubin. Le dimensioni iniziali previste sono paragonabili a quelle di una caramella (candy), ma si passa velocemente alla saponetta (bar of soap), con laggiunta di un modulo per la trasmissione - ricezione radio. Nasce cos Sidekick.

Figura 5: Sidekick 3, presentato nel 2006

Nel 2002 Rubin tiene una serie di seminari per presentare il proprio prodotto e, durante un incontro presso la facolt di ingegneria di Stanford, incontra Page e Brin. I due fondatori di Google, dopo aver ascoltato la presentazione, decidono di esaminare il dispositivo e Page, scoprendo che lo stesso utilizza Google come motore di ricerca predefinito, si lascia scappare uno spontaneo Cool. In realt Page accarezza da tempo lidea di uno smart-device con funzioni di telefonia incorporata, sulla falsa riga di quanto fatto da Microsoft con Pocket PC 2002 Phone Edition, e lascesa delle connessioni wireless sta aprendo nuovi scenari con utenti sempre connessi, ovunque si trovino. Entrambi i fondatori di BigG cominciano ad usare il Sidekick, ma non abbandonano lambizione di realizzare in proprio un prodotto similare (in realt non molto definito, e senza sapere se investire sullhardware, sul software o su entrambi).

Nel 2005 Google finanzia, con 2 milioni di dollari, un progetto di Nicholas Negroponte, fondatore dei M.I.T. Media Laboratory, per la creazione di un laptop wireless dal costo di 100$, a ulteriore dimostrazione del fatto che lazienda era alla ricerca di prodotti per estendere il proprio campo dazione nel settore mobile. Nello stesso anno arriva la svolta: Rubin, colpito dallinteressamento di Google, chiede di incontrare Page e, durante il meeting, pronunciando la semplice frase: Is this interesting to Google?, segna linizio dellera dellAndroide. Ma cosa propose esattamente Rubin a Page? Di preciso, ovviamente, difficile saperlo, ma sembra che il pap del Sidekick illustr a Page quello che riteneva il futuro: una serie di dispositivi (smart-phone) che permettessero agli utenti della telefonia mobile di connettersi ad internet ed estendere cos le possibilit di comunicazione in movimento. Rubin evidenzi come il mercato dei PC vedeva la vendita annuale (2005) di circa 200milioni unit, mentre quello della telefonia era di circa 700milioni. Nonostante ci, ogni telefonino disponeva di un proprio sistema operativo, chiuso e restio ad una evoluzione consona alla sua visione. In questo scenario la sua sturt-up, Android Inc. (Palo Alto - California), era in grado di offrire una nuova tipologia di Mobile OS: open (basata su Kernel Linux), attento agli standard, basato su una UI semplice e funzionale e corredato da una serie di strumenti pensati per facilitare la vita agli sviluppatori. Ma, soprattutto, il sistema era gratuito per chiunque volesse utilizzarlo, poich Rubin vedeva il proprio Business legato al supporto ed ai servizi accessori. Pi che il prodotto in se, a sbalordire Page fu il motivo per cui Rubin ha chiesto di vederlo: non si tratta di soldi (Android Inc. ha gi abbastanza fondi), ma la richiesta che Google desse al suo prodotto una sorta di imprimatur, ovvero che fosse il sistema mobile scelto da BigG, confermando la cosa anche con una semplice e-mail di pubblico dominio. Durante lesposizione di Rubin, Page era completamente concentrato sul prototipo Android-based, ben conscio che Google non era preparato alla sfida del Web Mobile, nonostante questa potesse rivoluzionare gli equilibri di mercato e scombussolare le proprie strategie (ADV e Search in primis). Inoltre cera Microsoft, la grande rivale, che stava cavalcando londa con la piattaforma Windows Mobile che, nonostante fosse ferma ad una quota di mercato del 10%, era comunque in rapida ascesa perch permetteva gi, in certa misura, quanto Rubin stava profetizzando. Nel 2005 Android Inc. si trasforma nella Google Mobile Division affidata, ovviamente, alla cura di Rubin e degli altri tre co-fondatori (Rich Miner, Nick Sears e Chris White). A novembre dello stesso anno nasce l Open Handset Alliance, un consorzio formato da 34 societ (tra cui Texas Instruments, Intel, T-Mobile,eSprint Nextel), con lintento di realizzare con Google un dispositivo wireless basato su un sistema Linux.

Nel novembre del 2007 Google scuote la comunit degli sviluppatori, pubblicando la prima versione pubblica (early look) dellAndroid Software Developer Kit e mettendo a disposizione 10 milioni di dollari per coloro che realizzeranno le migliori applicazioni per il nuovo sistema.

Google intenzionata a realizzare un ecosistema software che sia indipendente quanto pi possibile dallhardware ed aperto al mondo degli sviluppatori. Lidea quella di fornire un sistema flessibile e adattabile, pensato per il web (e i servizi di Google in particolare) e per essere personalizzato in ogni suo aspetto, comprese le App primarie come browser e client di posta elettronica. La strategia era delineata: riuscire a rendere semplice e user-friendly la navigazione web su dispositivi palmari, con Google punto di accesso al mondo della Rete. Il fatto che fosse una strategia vincente fu indirettamente confermato durante il periodo natalizio dello stesso anno, quando il lancio commerciale delliPhone port il 5% del traffico mondiale mobile sul motore di ricerca della societ di Mountain View. Ad agosto del 2008 la volta dellAndroid 0.9 SDK beta, sulla base del quale il gigante statunitense T-Mobile annuncia il T-Mobile G1 (settembre 2008), il primo smartphone basato su Android, annuncio seguito, pochi giorni dopo, dal rilascio dell Android SDK Release Candidate 1.0. A circa un mese di distanza (ottobre 2008) Google rilascia il codice sorgente di Android 1.0 sotto licenza Apache. Uno dei punti chiavi dello sviluppo applicativo per Android sempre stato quello di rendere possibile linterazione tra le varie App e la possibilit di riusare componenti trasversali, abbracciando il modello cloud-computing che abbatte il concetto di localizzazione delle risorse. La cosa fondamentale da evidenziare nella strategia di Google che Android non un sistema isolato, bens fa parte dellimmenso ecosistema della societ di Mointan View. Cos possibile sfruttare i servizi di Google Maps per la geo localizzazione, cos come facilmente utilizzabile il sistema di Picasa per caricare al volo una foto appena scattata con la fotocamere del proprio smart-phone.

Evoluzione di Android:

Android 1.0 e 1.1 La prima versione di Android (ottobre 2008) decisamente limitata, soprattutto se paragonata ai diretti competitor come iOS e Windows Mobile. La mancanza del supporto alle API per il Bluetooth e limpossibilit di utilizzare una tastiera virtuale, sono i due principali elementi che ne limitano la diffusione, soprattutto in un mercato sempre pi orientano verso lo scambio diretto di informazioni tra dispositivi e che guarda il mondo touch come la nuova frontiera. In realt gli auricolari Bluetooth, cosi come altre periferiche di questo tipo, sono supportate mentre a mancare invece la possibilit di sviluppare applicazioni basate su tale tecnologia wireless. Sono inoltre assenti le API per il servizio di messaggistica istantanea GTalk, rimosse per motivi di sicurezza in via temporanea. Neanche la versione 1.1 migliora la situazione, limitandosi a ottimizzare lambiente e supportare in modo pi appropriato alcune lingue europee (tedesco in primis).

Android 1.5 : Cupcake (minitorta) Con questa versione Google inaugura il trend di associare al proprio OS Mobile un codename dolciario. La versione 1.5, rilasciata ufficialmente ad Aprile 2009, viene infatti chiamata Cupcake, una sorta di minitorta molto in voga negli States. Si tratta del primo vero update per Android, che viene migliorato in molte aree e diventa decisamente pi performante del suo predecessore Tra le pi importanti novit troviamo molte funzionalit riguardanti la parte multimediale: stata infatti introdotta la possibilit di effettuare registrazioni video, cos come quella di caricare filmati su YouTube e riprodurli. Aggiunto anche il copia e incolla nel browser standard in dotazione. Da sottolineare la presenza dellatteso supporto al tastierino QWERTY virtuale, lintroduzione della funzionalit di riconoscimento vocale e le nuove cartelle live. Altri piccoli/grandi accorgimenti riguardano le performance del GPS, le API per lo sfruttamento dellaccelerometro da parte delle applicazioni ed il supporto alla tecnologia Bluetooth Stereo. Decisamente migliorati i Widget, ossia quelle piccole App attraverso cui ricevere costantemente informazioni aggiornate dai propri canali preferiti, come, ad esempio, il servizio meteo. Ancora assenti le API per lutilizzo del Bluetooth allinterno delle proprie App. 10

Android 1.6 : Donut (ciambella) Rilasciato a settembre del 2009, si tratta di un upgrade minore che comunque migliora alcune aree sensibili del sistema, particolarmente rilevanti per gli utenti finali. Vengono raffinati e resi pi accessibili gli strumenti di ricerca, che ora sono trasversali alle diverse applicazioni e ai tipi di contenuti (bookmark, contatti, ecc). Gli stessi vengono dotati di una sorta di intelligenza che li rene capaci di "imparare" dalle ricerche e offrire risultati sempre pi aderenti a quello che l'utente cerca. La compatibilit con le reti CDMA decisamente migliorata, cos come le funzionalit relative alla foto(vide)camera, che viene avviata circa il 39% pi velocemente e riesce a scattare foto ad una velocit superiore di quasi il 28%. Le impostazioni sono ora pi immediate, cos come lo switch tra la modalit foto/video. Anche la gestione della photo gallery stata completamente rivisitata e semplificata. Parallelamente l Android Market acquista una nuova veste grafica che lo rende pi user-friendly. Le App vengono suddivise tra: gratuite, a pagamento e just in e corredate dal relativo screenshot.

Android 2.0 : clair (Pasticcino) La versione 2.0 di Android viene rilasciata a Novembre del 2009 e si tratta di un importante passo in avanti per la piattaforma mobile del colosso di Mountain View. clair infatti la prima release ad attrarre la grande massa degli utenti smartphone, grazie alle nuove funzionalit ed una intensiva campagna marketing mirata a promuovere il prodotto. Android sbarca nel mondo social, permettendo alle applicazioni di sincronizzarsi con i contatti di Facebook e (successivamente) di Twitter, in modo da tenere tutto sotto controllo da un unico punto di accesso. Le immagini dei contatti vengono prese direttamente da Facebook e una volta posizionatosi su di esse appare un piccolo slide-menu(Quick Contact) che mostra tutte le possibilit di comunicazione con il contatto stesso. Eclair migliora ulteriormente le funzionalit della fotocamera, punto debole della serie 1.x. Finalmente troviamo: zoom digitale, scene mode, bilanciamento del bianco, effetto sui colori e macro focus. La virtual keyboard si arricchisce del supporto al multitouch e di un dizionario pi ricco per il supporto alla scrittura veloce (suggerita). Anche il browser standard viene rivisto, permettendo lo zoom con la doppia pressione del dito, senza la necessit di utilizzare i tasti +/-, fisici o virtuali che siano.I bookmark sono ora in grado di supportare le thumbnail delle pagine web ed garantita la piena adesione allo standard HTML5. Finalmente arrivano le API di sviluppo per utilizzare direttamente il bluetooth allinterno delle proprie applicazioni mobile. Nella strategia di integrazione con i servizi di BigG compare Google Maps Navigation, un sistema di navigazione GPS integrato con Google Maps. Il suo impatto sul mercato risulta dirompente, tant che il costo dei navigatori Garmin diminuisce immediatamente di circa il 16%, cos come quello dei Tom Tom che diminuisce addirittura del 21%. 11

In sintesi Android 2.0 porta in dote: Multiaccount GMail con sincronizzazione da pi account; Menu rapido su contatto alla pressione sulla sua immagine; API Bluetooth per abilitare liberamente lo scambio dati e qualsiasi altra funzione; Supporto a schermi di dimensione maggiore o inferiore a quella standard; Supporto Exchange; Ricerca fra gli SMS e gli MMS; Fotocamera: supporto al flash, zoom digitale, modalit di scatto, bilanciamento del bianco, effetti e macro; Tastiera virtuale pi veloce con supporto al multitouch; Browser: preferiti con anteprima, supporto a HTML5; Supporto dello scroll infinito per lAgenda; Calendario: permette di invitare persone.

Android 2.1 clair (Pasticcino) & 2.1 Update 1 (Multi-touch) Android 2.1 il secondo step evolutivo di clair (di cui mantiene la denominazione), rilasciato in concomitanza con la disponibilit del terminale Nexus One (gennaio 2010). Si tratta, sostanzialmente, di un raffinamento della precedente release 2.0, che introduce alcune feauture interessanti come le 5 virtual home screen concorrenti per organizzare il proprio lavoro, invece delle tre precedenti, navigabili attraverso le loro miniature. Alcune funzionalit vengono introdotte per puro divertimento e miglioramento estetico, come le wallpaper animate e la nuova e moderna photo gallery 3D, una delle migliori App integrate nel sistema fin ora. Gli effetti 3D, per, non si limitano comunque alla sola photo gallery, ma sono estesi a tutta la UI del sistema, con effetti animati anche allapertura delle varie applicazioni. A solo un mese di distanza, Google presenta un piccolo aggiornamento (update 1) che introduce una funzionalit attesa da parecchio tempo: il supporto al multitouch, estendendolo di default a tutte le applicazioni che interagiscono con i servizi Google. Laggiornamento aggiunge anche Google Goggles tra le applicazioni pre-installate e aggiorna Google Maps alla versione 3.4, con nuove interessanti feauture. Da segnalare infine la correzione di un bug relativo alla connessione 3G.

Android 2.2 : Froyo (Frozen Yogurt, Yogurt Gelato) Froyo viene rilasciato da Google a Maggio del 2010. Rispetto al suo diretto predecessore (Eclair 2.1), questa nuova release incrementa di circa 7 volte le performance del sistema, grazie al compilatore Dalvik JIT e allEngine V8 di Java. Con il primo le applicazioni vengono lanciate pi velocemente, cos come lintero sistema risponde in modo pi fluido. LEngine Java V8, lo stesso presente su Chrome, rende lesperienza Web con Froyo la pi veloce nel settore degli OS mobile, grazie al browser integrato che carica in modo fulmineo le pagine web.

12

Froyo introduce il tethering WiFi ed USB, con il quale possibile utilizzare il terminale come hot spot per accedere ad Internet, sfruttandolo, praticamente, come modem esterno. Questa funzione si rileva molto utile in accoppiata con i notebook/netbook e sostituisce le App di terze parti che, tra laltro, richiedevano i diritti di ROOT. Froyo offre pieno supporto al FlashPlayer di Adobe, con performance di primordine che permettono di riprodurre i contenuti in modo decisamente fluido e, sempre sul versante multimediale, si segnala un nuovo ed avanzato lettore multimediale. Minori, invece, le migliorie alla photo gallery e alla fotocamera, dove, ad esempio, ora possibile utilizzare il flash come luce per girare filmati in condizione di scarsa luminosit. La tastiera virtuale offre il supporto a vari linguaggi indipendentemente dalla lingua con cui il dispositivo stato settato, cos come la ricerca vocale in grado di adattarsi a pi culture. La nuova release 2.2 di Android porta, di riflesso, diversi miglioramenti per il Market, tra cui lautoupdate delle varie applicazioni installate (singolarmente o in modo cumulativo) ed un rinnovato sistema di ricerca delle App stesse. Con questa nuova versione, infatti, finalmente possibile installare le applicazioni sulla memory card del telefono, per liberare lo spazio nella memoria interna, solo, per, su esplicita richiesta. Anche i Developer sono destinatari di una serie di novit, grazie allintroduzione di nuove API che permettono: supporto della bussola digitale in Maps; possibilit di scaricare le applicazioni da PC ed installarle direttamente sul telefono in modalit wireless; impostare una destinazione tramite Maps su Google Chrome da PC e trasferirla direttamente sullo smartphone in modalit wireless; possibilit di sincronizzazione con iTunes collegando il cavo audio allo smartphone.

Android 2.3 Gingerbread (Pan di Zenzero) Android 2.3 Gingerbread viene ufficialmente rilasciato da Google a dicembre del 2010. BigG non stenta a definire Gingerbread come la "versione di Android pi veloce di sempre", grazie alle ulteriori ottimizzazioni a cui stato sottoposto il compilatore JIT. Questa nuova versione porta con se diverse nuove funzionalit e caratteristiche di grande interesse, rendendolo di fatto ideale per i dispositivi smartphone top class di ultima generazione. Tra queste troviamo il supporto al sistema NFC (Near Field Communication), che permette comunicazioni bidirezionali a breve distanza consentendo di utilizzare il terminale come borsellino elettronico per micro-pagamenti. La nuova interfaccia pi intuitiva e veloce, il che semplifica le operazioni pi evolute come il copia e incolla che ora permette di selezionare una parola premendo semplicemente con il dito su di essa e di evidenziare la parte di testo da copiare spostando due indicatori. La stessa tastiera virtuale stata ridisegnata ed ottimizzata per consentire una digitazione ed una eventuale modifica del testo pi veloce e precisa, il tutto supportato dal nuovo dizionario che permette una pi rapida correzione degli errori. 13

Le App-Game possono ora contare sui driver OpenGL ES, che sfruttano appieno lhardware disponibile, ed una gestione pi completa del comparto audio tramite le API Khronos OpenSL ES. Degno di nota il supporto alle chiamate via internet tramite protocolli SIP e VoIP e il nuovo download manager, tramite cui possibile accedere facilmente a qualsiasi file che sia stato scaricato dal browser, dalla mail, ecc. Da segnalare, infine, il migliorato supporto agli schermi tablet tramite il parametro xlarge, che si affianca a quelli small, medium e large.

Android 2.4 IceCream (gelato) Android 2.4 Ice Cream una versione di transazione che dovrebbe avvicinare le caratteristiche di Android 2.3 Gingerbread alle caratteristiche di Android 3.0 Honeycomb, pensato specificamente per i Tablet. In particolare sembra che Google voglia arrivare ad avere un unico sistema operativo mobile in grado di adattarsi ai differenti dispositivi, esattamente sulla scia di quanto intrapreso da Apple con iOS e Microsoft con Windows Embedded. Tra le novit che potrebbero arrivare sulla versione per smartphone in pole position la tecnologia RenderScript Technology, che permetter agli sviluppatori di creare interfacce 3D pi fluide e sofisticate. Inoltre Ice Cream potrebbe far proprio il supporto ai processori dual-core e l'accelerazione hardware per il rendering 2D.

Android 3.0 Honeycomb (Nido) Android 3.0 Honeycomb (2 febbraio 2011) appositamente pensato per sfruttare adeguatamente la potenza e gli ampi touchscreen in dotazione ai Tablet, ed accompagnato dalla nuova sezione del sito android.com dedicata al catalogo delle App specifiche. Il logo ufficiale segue il trend dolce inaugurato con la versione 1.5, presentando una versione mielosa del robottino mimetizzato da Ape. Tra le novit introdotte da Honeycomb troviamo: una nuova interfaccia grafica divisa in tre aree distinte, che sfrutta maggiormente i widget organizzati in stack, un nuovo sistema di notifiche avanzate e un multitasking pi reattivo che utilizza anche una piccola anteprima per aiutare a identificare l'attivit associata ad ogni applicazione aperta. Le App standard vengono interessate da una serie di miglioramenti ed aggiornamenti che si aggiungono al supporto nativo alla videochiamata, all'accelerazione grafica hardware e al supporto per i processori multi-core. Come dicevamo, Android 3.0 pensato per i dispostivi Tablet, anche se probabile che molte di queste funzioni arriveranno successivamente anche sugli smartphone. Anche lAndroid Market si rif il look ed ora disponibile la relativa versione web, accessibile direttamente attraverso il browser del PC, divisa nelle classiche categorie con la possibilit di lasciare un commento sulla qualit dellAPP acquistata/scaricata. In sintesi, in Honeycomb troviamo: 14

Interfaccia disegnata per i tablet: uninterfaccia utente disegnata su misura per i tablet, con vero multitasking, sistema di notifiche migliorato, widget ed elementi in 3D; Retrocompatibilit applicazioni: la maggior parte delle applicazioni realizzate per le versioni precedenti del sistema funzionano perfettamente su Android 3.0, ma quelle disegnate su misura per questultimo potranno avere funzionalit uniche (grafica, multimedia, integrazione nella UI, ecc.); Barra di sistema: sempre disponibile nella parte bassa dello schermo, la nuova barra di sistema fornisce un accesso immediato a notifiche, orario e pulsanti di navigazione. Barra delle azioni: non avendo pi bisogno di tasti fisici, Honeycomb si presenta con una barra per la gestione delle applicazioni a 360 posizionata nella parte alta dello schermo (un po come accade in Mac OS X); Home Screen personalizzabili: in Android Honeycomb si possono mantenere e personalizzare fino a 5 home screen contemporaneamente. Ognuna delle quali pu avere i propri widget, il proprio sfondo e le proprie icone; Applicazioni recenti: con il menu delle applicazioni recenti Android 3.0 fornisce un vero multitasking, consentendo allutente di visualizzare unanteprima di tutte le applicazioni aperte nel loro stato attuale e di passare velocemente da un task allaltro; Tastierino virtuale: Honeycomb ha un tastierino QWERTY virtuale ridisegnato per lutilizzo sugli schermi dei tablet; Connettivit: il nuovo Android per tablet permette di sincronizzare file multimediali con fotocamere e computer connessi tramite USB senza bisogno di montarli come memorie di massa, supporta tastiere e mouse USB e Bluetooth, presenta una connettivit Wi-Fi migliorata e un nuovo supporto al tethering Bluetooth, che consente di condividere la connessione tra smartphone e una moltitudine di dispositivi con cui prima non era possibile farlo.

Android 4 Ice Cream Sandwich (gelato al biscotto) Attualmente lultima versione di Android, rilasciata nel mese di ottobre 2011.

15

Creare lambiente di sviluppo

Nel presente capitolo vengono elencati i software necessari alla creazione di applicazioni Android e la loro modalit di installazione:

Java Development Kit (JDK); Android Development Kit (ADK); Integrated Development Environment (IDE); (ambiente di sviluppo integrato, useremo Eclipse)

Android Development Tool (ADT).


( un plug-in rilasciato da Google per Eclipse che permette di integrare in Eclipse i tool per la compilazione, il testing e il debugging del codice rilasciati con l'Android SDK. Consente di creare un emulatore Android , lAVD, per il quale possibile scegliere sia la versione dellSDK Android che la memoria riservata sulla scheda SD del dispositivo.)

Passi da seguire per una corretta creazione dellambiente di sviluppo:

Scarichiamo e installiamo lSDK Java


L SDK Java reperibile dalla pagina di download dal sito della Oracle (http://www.oracle.com/technetwork/java/javase/downloads/index.html) .Verr chiesto per quale sistema operativo si desidera scaricare Java SDK e quale versione. Attualmente, lultima versione di Java SDK la Java 7.

Scarichiamo e installiamo lAndroid SDK


Visitiamo il sito degli sviluppatori Android allindirizzo http://developer.android.com/sdk/index.html e scarichiamo la versione per il nostro sistema operativo.

16

Una volta terminato il download lanciamo installer_r10-windows.exe e portiamo a termine il Wizard di installazione. Dopodich lanciamo lSDK Manager.

Il manager ci consente di decidere quali package installare. E possibile scaricare diversi SDK, uno per ogni versione Android, inclusa la relativa documentazione, gli esempi e i driver USB di Google. Una volta che abbiamo selezionato quello che desideriamo installare premiamo il pulsante Install.

Scarichiamo e installiamo Eclipse


Come IDE di sviluppo utilizzeremo Eclipse. Visitare la pagina http://www.eclipse.org/downloads/e selezionare la versione appropriata di Eclipse. Per sviluppare su Android potrebbe essere sufficiente scaricare Eclipse IDE for Java Developers, pi piccolo e leggero,alternativamente si pu scaricare Eclipse IDE for Java EE Developers.

Una volta terminato il download sufficiente scompattare il file, copiare la cartella dove si desidera e creare un collegamento a eclipse.exe .Eclipse non richiede infatti nessuna installazione particolare.

Scarichiamo il Plugin ADT


Avviamo Eclipse, poi selezioniamo Help > Install New Software facciamo click su Add

17

Nella dialog Add Repository che compare inseriamo ADT Plugin per il nome e lurl seguente per la locazione: https://dl-ssl.google.com/android/eclipse/

Facciamo click su OK. Nel dialog Available Software selezioniamo la checkbox accanto a Developer Tools e facciamo click su Next. Nel next window vediamo una lista di tool da scaricare.

18

Facciamo click su Next. Accettiamo il license agreements e facciamo click su Finish.

Terminata linstallazione riavviamo Eclipse.

Configuriamo il Plugin ADT


Scaricato il plugin ADT come descritto nel punto precedente andiamo ad impostare nelle preferenze ADT in Eclipse il puntamento alla directory in cui abbiamo installato lAndroid SDK. Selezioniamo Window >Preferences per aprire il pannello delle preferenze. Selezioniamo Android dal pannello a sinistra e selezioniamo la cartella dove la Android SDK installata.

19

Facciamo click su Apply.

Creiamo un AVD
Siamo ora pronti per creare un AVD. Avviamo lAVD Manager e facciamo click suVirtual devices. Facciamo click su New e creiamo un nuovo dispositivo virtule come mostrato di seguito:

20

E ora possibile lanciare il dispositivo appena creato in emulazione:

Figura 6: Schermata principale del simulatore di Eclipse

21

Architettura di Android

Android non una piattaforma hardware ma bens un ambiente software progettato appositamente per dispositivi mobili. Nella figura seguente viene mostrata la stratificazione dellarchitettura di Android.

Figura 7: Architettura Android

Il cuore del sistema basato sul kernel di Linux (versione 2.6) che costituisce il livello di astrazione di tutto lhardware sottostante. Direttamente nel kernel, infatti, sono inseriti i driver per il controllo dellhardware del dispositivo: driver per la tastiera, lo scremo, il Wi-Fi, bluetooth, GPS, fotocamera, touchscreen I produttori di telefoni possono quindi intervenire gi a questo livello per personalizzare i driver di comunicazione con i propri dispositivi. Grazie allastrazione dellhardware, i livelli soprastanti non si accorgono dei cambiamenti hardware, permettendo una programmazione ad alto livello omogenea ed una user experience indipendente dal device. Il kernel di Linux di Android un sistema multi-utente nel quale ogni applicazione un utente differente. Il sistema infatti crea un unico user ID per ogni applicazione (sconosciuto ad essa) e imposta i permessi dei file dellapplicazione stessa in modo che solo quellID possa averne accesso. Inoltre, ogni applicazione sul telefono viene lanciata in un processo Linux a s stante allinterno della propria istanza della Java Virtual Machine(JVM): questa archiettura a sandbox garantisce la stabilit del telefono nel caso in qui qualche applicazione crei problemi. In caso alcune applicazioni abbiano necessit di comunicare tra loro, il sistema non lo impedisce: permette anzi loro di condividere lo stesso user ID e la stessa JVM in modo da preservare la coerenza delle risorse di sistema. A differenza di un kernel Linux standard per Android sono stati aggiunti ulteriori moduli come: 22

Binder IPC Driver, un driver dedicato che permette a processi di fornire servizio ad altri processi attraverso un insieme di API di pi alto livello rispetto a quelle presenti su un kernel linux standard, ci permette la comunicazione tra processi con un costo computezionale minore e un relativo minore consumo di batteria; Low Memory Killer, un sistema che si preoccupa di terminare i processi liberando cos spazio nella memoria centrale per soddisfare le richieste di un altro processo. La terminazione dei processi avviene secondo un sistema di ranking che assegna dei punteggi ai processi; i processi che verranno terminati saranno quelli con punteggio pi alto. Ad esempio, un processo che controlla la UI (User Interface) di un'applicazione visibile sar sicuramente pi basso di quello relativo ad un'applicazione non visibile sullo schermo. Il processo init non pu essere terminato; Ashmem, un sistema di memoria condiviso anonimo (Anonimous Shared Memory) che definisce interfacce che consentono ai processi di condividere zone di memoria attraverso un nome. Il vantaggio di Ashmem rispetto ai sistemi Linux che fanno uso della memoria condivisa, che viene fornito al kernel uno strumento per recuperare dei blocchi di memoria non utilizzati; RAM Console e Log devices, per agevolare il debugging, Android fornisce la capacit di memorizzare i messaggi di log generati dal kernel in un buffer RAM. disponibile inoltre un modulo separato che permette ai processi utente di leggere e scrivere messaggi di log; Android Debug Bridge, uno strumento che permette di gestire in maniera versatile un'istanza dell'emulatore o eventualmente di un dispositivo reale; Power Management, sezione progettata per permettere alla CPU di adattare il proprio funzionamento al fine di non consumare energia se nessuna applicazione o servizio ne fa richiesta.

Al livello superiore troviamo delle librerie native, realizzate in C / C++, che rappresentano il vero e proprio core del sistema oeprativo: Surface Manager: il modulo che gestisce le View, cio i componenti di una interfaccia grafica. Funziona praticamente come uno scheduler per la gestione della visualizzazione delle interfacce grafiche e previene eventuali problemi di accavallamento scoordinato sul display. E' un componente di vitale importanza per un terminale che fa delle interfacce grafiche un punto di forza del suo funzionamento; Open GL SE: una libreria grafica, versione light della libreria OpenGL per terminali mobili, che permette di utilizzare grafica 3D; SGL (Scalable Graphics Library): libreria scritta in C++ che permette di gestire la grafica 2D; Media Framework: componente in grado di gestire i contenuti multimediali (Codec per l'acquisizione e riproduzione di contenuti audio e video); FreeType: componente che gestisce i font; SQLite: Database relazionale piccolo ed efficiente messo a disposizione dello sviluppatore per la persistenza dei dati nelle varie applicazioni sviluppate; WebKit: browser engine open source (utilizzato anche per i pi conosciuti browser web Safari e Chrome). Da sottolineare che non si tratta di un browser web, quindi dovr essere integrato nelle diverse applicazioni; SSL: si tratta della famosa libreria per la gestione del Secure Socket Layer. 23

Android inserisce un layer di astrazione tra librerie di sistema ed il sistema operativo Linux per unificare casi specifici di comportamenti driver non standard e fornire un livello di separazione tra componenti Android e software GPL. Lintero Layer sviluppato in C/C++ e definisce, per ogni tipologia di dispositivo, uninterfaccia di controllo da implementare in uno stub di comunicazione verso il driver Linux vero e proprio oppure, in genere, verso linterfaccia esposta da una famiglia di driver. Lambiente di runtime costituito invece da una libreria Core e da una macchina virtuale (VM): insieme costituiscono la piattaforma di sviluppo per Android. La VM di Android (chiamata Dalvik) una versione particolare della Java Virtual Machine, progettata e ottimizzata appositamente per girare su hardware non performanti, come quelli dei cellulari appunto. La Dalvik Virtual Machine esegue i files nel formato Dalvik Executable (.dex), generati a partire dal bytecode Java. I file .dex, hanno un tipo di compressione che permette di dimezzare lo spazio utilizzato rispetto ai file .jar non compressi. Anche la Dalvik Virtual Machine, similmente per quanto accade per la JVM, implementa un Garbage Collector, liberando pertanto lo sviluppatore dall'onere della gestione della memoria. In una architettura Android non esiste dunque alcuna JVM e non viene eseguito alcun bytecode Java ma le applicazioni Android vengono comunque scritte in Java. Cerchiamo di dare una spiegazione a tale affermazione, la quale risulta quantomeno contraddittoria. La naturale conseguenza al fatto di utilizzare il linguaggio Java sarebbe stata quella di avvalersi di una piattaforma Java Standard Edition o Java Mobile Edition. Questultima un sottoinsieme della Java SE ottenuta eliminando quelle istruzioni ed API non in grado di poter essere eseguite in un dispositivo con risorse limitate in termini di CPU e memoria. La Java ME non quindi stata pensata appositamente come piattaforma mobile ma come "linsieme delle API che funzionano anche in dispositivi mobili". La OHA e Google hanno quindi deciso che la cosa migliore per la realizzazione di una piattaforma mobile fosse quella di creare subito qualcosa di ottimizzato. Di contro, vi era la necessit di rendere relativamente semplice la realizzazione di applicazioni Android. Le possibilit erano quelle di creare un nuovo linguaggio oppure di utilizzarne uno esistente ereditando una community di sviluppatori e soprattutto un insieme maturo di strumenti di sviluppo. La scelta caduta su Java non solo per questi motivi ma anche per la possibilit di avere a disposizione un bytecode di specifiche conosciute e quindi modificabile e ottimizzabile a piacere. Il compromesso stato dunque quello di dare la possibilit di sviluppare applicazioni Android in Java sfruttando i tool di sviluppo cassici come Eclips o NetBeans per poi trasformare il bytecode Java in Dalvik byte code. Ecco perch le Core libraries e tutte le API a disposizione nella realizzazione di applicazioni sono Classi Java. In particolare, le API sono quelle relative a Java SE e non alla JavaME. Concludiamo tale inciso asserendo che lapplicazione in esecuzione sul dispositivo Android viene eseguita allinterno di una VM che strettamente legata alle risorse del sistema operativo Linux. Questo significa che lapplicazione pseudo-Java praticamente nativa rispetto al dispositivo con notevoli vantaggi dal punto di vista delle prestazioni. Al penultimo livello possibile rintracciare i gestori e le applicazioni di base del sistema. Gli sviluppatori hanno pieno accesso alle stesse framework API usate dalle applicazioni di base. Larchitettura delle applicazioni progettata per semplificare il riutilizzo dei componenti; ogni applicazione pu rendere pubbliche le sue capacit e tutte le altre applicazioni possono quindi farne uso (sono soggette ai limiti imposti dalla sicurezza del framework). Questo stesso meccanismo consente all'utente di sostituire i componenti standard con versioni personalizzate. Nell' Application Framework, lo sviluppatore ha dunque a disposizione una serie di API che sfruttano le librerie sottostanti di Android. Sono presenti i seguenti moduli:

24

Activity Manager: modulo che gestisce tutto il ciclo di vita delle activity. Le activity sono entit associate ad una schermata, rappresentano quindi l'interfaccia verso l'utente. Il compito dell'Activity Manager quello di gestire le varie activity sul display del terminale e di organizzarle in uno stack in base all'ordine di visualizzazione sullo schermo; Package Manager: modulo che gestisce i processi di installazione e rimozione delle applicazioni dal sistema; Telephony Manager: modulo che gestisce l'interazione con le funzioni tipiche di un cellulare; Content Provider: modulo che gestisce la condivisione di informazioni tra i vari processi attivi. Il suo utilizzo simile a quello di un repository comune nel quale i vari processi possono leggere e scrivere informazioni; Resource Manager: modulo deputato alla gestione delle informazioni relative ad una applicazione (file di configurazione, file di definizione dei layout, immagini utilizzate, ); View System: gestisce l'insieme delle viste utilizzate nella costruzione dell'interfaccia verso l'utente (bottoni, griglie, text boxes, ); Location Manager: modulo che mette a disposizione dello sviluppatore una serie di API che si occupano della localizzazione. Esistono due provider per la localizzazione: GPS e NETWORK. GPS utilizza i satelliti geostazionari per il posizionamento geografico, ha bisogno per della vista del cielo e risente delle cattive condizioni atmosferiche. NETWORK utilizza punti dei quali si conosce la posizione geografica, come ad esempio celle GSM oppure reti wireless geolocalizzate (Hot Spot); Notification Manager: mette a disposizione una serie di meccanismi utilizzabili dalle applicazioni per notificare eventi al dispositivo che intraprender delle particolari azioni in conseguenza della notifica ricevuta.

Al livello pi alto risiedono le applicazioni utente tipo email client, un programma SMS, calendario, mappe, browser, contatti e altro. Le funzionalit base del sistema, come per esempio il telefono, non sono altro che applicazioni utente scritte in Java e che girano ognuna nella sua Dalvik Virtual Machine. Infine, concludiamo questa descrizione dellarchitettura Android citando la possibilit di scrivere codice C/C++ in Android grazie allausilio della Android Native Development Kit (NDK). Si tratta di un toolkit complementare alla SDK: infatti non pu essere scritta una applicazione completamente in NDK. In generale, la scelta di lavorare in nativo da prendere in considerazione quando si ha necessit di elevate prestazioni di calcolo con basso consumo di memoria. Come abbiamo detto la SDK e la NDK sono complementari: lapplicazione verr creata come di consueto tramite le API della SDK, mentre qualche algoritmo potr essere delegato alla NDK tramite tramite la Java Native Interface (JNI) library.

25

Componenti di una applicazione Android

Ogni applicazione Android si compone di 4 diverse tipologie di componenti:

Activity; Content Provider; Broadcast Receiver: - Intent; Service.

Activity: La Activity il mattone alla base dellinterfaccia utente e normalmente rappresenta una singola
schermata della nostra applicazione. Le applicazioni possono definire una o pi Activity per trattare diverse fasi del software: ogni Activity responsabile del salvataggio del proprio stato in modo da poterlo ristabilire successivamente come parte del ciclo di vita dell'applicazione. Generalmente una Activity corrisponde ad un'azione specifica che l'utente pu fare: essendo una delle componenti principali nel ciclo di vita di ogni applicazione Android, il modo in cui le Activity sono lanciate e in cui interagiscono tra loro una parte fondamentale nello sviluppo con la piattaforma Android. Ci pu essere solo una Activity attiva per volta, quindi una sola Activity per volta pu essere in "primo piano" (foreground) nello stesso tempo: una Activity che in un determinato momento non si trova nello stato attivo e quindi non si trova in foreground (in questo caso si dice che l'Activity si trova in backgroud) potrebbe essere terminata dal sistema operativo ad esempio perch la memoria diventa insufficiente. Questo significa che ogni applicazione Android pu cambiare lo stato in ogni momento e deve essere pronta ad essere interrotta e chiusa in ogni istante. Come vedremo la classe Activity dispone di un numero notevole di callback che permettono ad una Activity di rispondere agli eventi come la sospensione e la ripresa.

Content Provider: costituiscono un livello di astrazione per i dati memorizzati a livello di device e a
disposizione di pi applicazioni. Il modello di sviluppo Android incoraggia a rendere i dati disponibili alle altre applicazioni: un Content Provider fa proprio questo, pur lasciando il controllo completo di come i dati vengono acceduti. Un Content Provider dunque un contenitore di dati e rappresenta uno dei modi migliori per condividere informazioni "globali" tra applicazioni. Nel modello di sicurezza implementato in Android, i file scritti da una applicazione non possono essere letti o scritti da un'altra. Android un sistema Linux-based in cui ogni applicativo ha il suo userid Linux, la sua directory "data" (/data/data/nome_pacchetto) e il suo spazio di memoria dedicato e protetto. Questo il motivo per cui gli applicativi Android necessitano dei Content Provider per comunicare tra loro. I processi possono segnalare se stessi al sistema come Content Provider di un insieme particolare di dati: quando queste informazioni sono richieste vengono richiamate da Android grazie ad un insieme specifico di API che permettono di agire sul contenuto secondo le specifiche definite. Alcuni Content Provider, ad esempio, forniscono l'accesso ai proprio dati solo in lettura, mentre altri permettono alle applicazioni di creare, aggiornare, modificare o cancellare record, come nel caso di quella che gestisce i contatti. 26

Un database SQLite in un device Android un esempio di sorgente di dati che possiamo incapsulare all'interno di un Content Provider. Android provvisto di un insieme di Content Provider nativi, documentati nel package "android.provider" dell'SDK. Possiamo vedere la lista di questi Content Provider sul sito degli svilupppatori Android (http://developer.android.com//reference/android/provider/package-summary.html). Per accedere alle risorse fornite da un Content Provider utilizziamo un insieme di URL caratterizzati dallo schema "content://" con un modello che ricorda molto da vicino le chiamate REST.

Broadcast Receiver: se unapplicazione deve ricevere e rispondere a un evento globale (arrivo di una
chiamata o di un SMS) deve registrarsi come Broadcast Receiver. Unapplicazione si registra come ricevitore di Intent in diversi modi. Un Intent un meccanismo che descrive un'azione specifica, come ad esempio "chiamare a casa" o "inviare un sms": in Android praticamente ogni azione passa attraverso un Intent. Ad esempio disponibile un Intent "inviare una email": se nella nostra applicazione abbiamo la necessit di gestire l'invio di email possiamo invocare l'Intent che il sistema ci mette a disposizione, oppure possiamo scriverne uno nuovo e utilizzare quest'ultimo nelle nostre Activity sostituendo l'Intent di default con quello implementato da noi. E possibile rispondere agli intenti o crearne di propri, per lanciare altre attivit o per farsi notificare del verificarsi di certe situazioni (ad esempio possibile lanciare un intento quando lutente pi vicino di 100 metri a una certa locazione).

Possiamo immaginare un Intent come un'azione che possiamo far invocare ad Android: un Intent pu essere molto specifico ed essere richiamabile da una specifica Activity oppure pu essere generico e disponibile per qualsiasi Activity che rispetta determinati criteri. Schematizzando, un Intent pu essere utilizzato per: lanciare una particolare Activity o Service; notificare cambiamenti di stato hardware; notificare dati in ingressi ( arrivato un SMS) ; supportare l'interazione tra qualsiasi applicazione installata sul dispositivo Android.

L'Intent uno dei concetti e dei meccanismi fondamentali di Android: la sua implementazione trasforma ogni dispositivo Android in una collezione di componenti indipendenti ma facenti parte di un singolo sistema interconnesso.

Service: le Activity, i Content Provider e i Broadcast Receiver sono di breve durata e possono essere
terminati in ogni istante. I Service, invece, sono progettati per rimanere attivi anche indipendentemente da una Activity.

27

Un Service dunque un processo che lavora in background senza la diretta interazione con l'utente. La classe Service viene utilizzata per creare componenti software che possono svolgere attivit in modo "invisibile", senza interfaccia utente. Un esempio tipico di Service lo vediamo implementato nel player di musica, che continua a riprodurre canzoni anche quando non in primo piano (foreground) e stiamo utilizzando altri programmi. Il codice responsabile di questa attivit sar implementato in un Service, al quale successivamente un'altra Activity potr "ordinare" di cambiare traccia o di fermare la musica. Un Service pu essere avviato, fermato e controllato da altri componenti dell'applicazione, inclusi altri Service e Activity. Se la nostra applicazione deve svolgere attivit che non dipendono direttamente dall'input inserito dall'utente, allora implementare un Service potrebbe essere la risposta alle nostre necessit: applicazioni che si aggiornano regolarmente ma che raramente o ad intermittenza interagiscono con l'utente sono buone candidate ad essere implementate come Service. Un Service avviato ha una priorit pi alta rispetto ad Activity in stato di inattivit, in questo modo vi minore probabilit per un Service di essere terminato dal gestore delle risorse di runtime. L'unica ragione per cui Android potrebbe fermare un Service prematuramente per fornire risorse addizionali al componente software in primo piano (normalmente una Activity). Quando questo si verifica il Service fermato sar riavviato automaticamente non appena le risorse diventano nuovamente disponibili. Nel caso in cui il Service debba interagire direttamente con l'utente potrebbe essere necessario incrementare la sua priorit come quella di un'Activity in foreground. Questo ci assicura che i nostri Service non vengano terminati se non in circostanze estreme, chiaramente per a scapito della gestione delle risorse a tempo di esecuzione, potenzialmente con un conseguente degrado generale dell'esperienza utente.

Gestione dei componenti


Le attivit sono i componenti base delle applicazioni Android poich fanno uso del display ed interagiscono con lutente. Di fatto, una Attivit una Classe che estende android.app.Activity. Lautore del codice, realizzando lattivit, si serve dei metodi ereditati da Activity per controllare cosa appare nel display, per assorbire gli input dallutente, per intercettare i cambi di stato e per interagire con il sistema sottostante. possibile mandare in esecuzione pi attivit simultaneamente, ma soltanto unattivit alla volta pu occupare il display. Lattivit che occupa il display in esecuzione e interagisce direttamente con lutente. Le altre, invece, sono ibernate e tenute nascoste in sottofondo, in modo da ridurre al minimo il consumo delle risorse di calcolo. Il cambio di attivit pu anche avvenire a causa di un evento esterno. Il caso pi ricorrente quello della telefonata in arrivo. I casi, invece, in cui unattivit pu terminare sono due: Lattivit ibernata e il sistema, arbitrariamente, decide che non pi utile e perci la distrugge. Il sistema a corto di memoria, e per recuperare spazio inizia a uccidere bruscamente le attivit in sottofondo.

La figura seguente mostra la sequenza di chiamate ai metodi Activity eseguiti durante i passaggi di stato dell attivit. 28

Figura 8: ciclo di vita delle Attivit

I vari metodi utilizzabili sono elencati di seguito: protected void onCreate(android.os.Bundle savedInstanceState): richiamato non appena lattivit viene creata. Largomento savedInstanceState serve per riportare un eventuale stato dellattivit salvato in precedenza da unaltra istanza che stata terminata. Largomento null nel caso in cui lattivit non abbia uno stato salvato; protected void onRestart(): richiamato per segnalare che lattivit sta venendo riavviata dopo essere stata precedentemente arrestata; protected void onStart(): richiamato per segnalare che lattivit sta per diventare visibile sullo schermo; protected void onResume(): richiamato per segnalare che lattivit sta per iniziare linterazione con lutente; protected void onPause(): richiamato per segnalare che lattivit non sta pi interagendo con lutente; 29

protected void onStop(): richiamato per segnalare che lattivit non pi visibile sullo schermo; protected void onDestroy(): richiamato per segnalare che lapplicazione sta per essere terminata.

le attivit, attraverso un intent-filter, possono essere attivate in risposta ad uno specifico evento. Gli intentfilter accettano figli di tre tipi: <action android:name="nome-azione"> individua gli intent che richiedono lazione specificata; <category android:name="nome-categoria"> individua gli intent che appartengono alla categoria specificata; <data android:mimeType="nome-tipo-mime"> <data android:scheme="nome-schema-url"> individua gli intent che portano dati del tipo specificato.

Unattivit dotata di un intent-filter che include lazione android.intent.action.MAIN e la categoria android.intent.category.LAUNCHER viene identificata come lattivit principale dellapplicazione. Ci significa che lapplicazione sar elencata nel men di sistema e che, quando lutente lavvier, sar lanciata proprio lattivit marcata in tale maniera. Unapplicazione Android pu contenere pi di unattivit. Una soltanto sar marcata come attivit principale di lancio. Le altre saranno, invece, delle sotto-attivit, che lattivit principale potr lanciare quando ce n bisogno. Realizzare una sotto-attivit semplice tanto quanto realizzare lattivit principale: ancora una volta sufficiente estendere android.app.Activity. Le attivit secondarie vanno poi registrate nel file AndroidManifest.xml, senza per applicare lintent-filter con lazione e la categoria usate invece dallattivit principale. Lattivit principale pu lanciare delle sottoattivit ricorrendo al metodo startActivity(). Questo accetta come argomento un oggetto di tipo android.content.Intenet che, come facile intuire, rappresenta un intent. Con questo intento bisogna esprimere quale sottoattivit deve essere avviata. Un servizio pu invece essere utilizzato in due modi: pu essere lanciato da un client invocando il metodo Context.startService(Intent) e fermato utilizzando il metodo Context.stopService(Intent); oppure il servizio si pu anche fermare in maniera autonoma attraverso la chiamata al metodo Service.stopSelf() oppure Service.stopSelfResult(). Per fermare un servizio occorre chiamare stopService() una volta sola mentre il metodo startService() pu essere invocato pi volte; se il client ha bisogno di interagire con le funzionalit che il servizio mette a disposizione attraverso la pubblicazione della sua interfaccia, deve stabilire una connessione con il servizio stesso utilizzando il metodo Context.bindService(). Questa connessione pu essere chiusa invocando il metodo Context.unbindService(). Pi client possono registrarsi allo stesso servizio il quale, se non attivo, pu essere lanciato con il metodo bindService().

Quando un messaggio broadcast giunge al ricevitore, Android chiama il relativo metodo onReceive() passando loggetto Intent contenente in messaggio. Il broadcast receiver viene considerato attivo solo durante lesecuzione del metodo onReceive(), quando questo metodo termina la sua esecuzione il receiver torna ad essere inattivo. Un processo che detiene un broadcast receiver attivo non pu essere ucciso. 30

Struttura di un progetto Android


Per la stesura di tale capitolo si ipotizzer di dover creare una semplice applicazione Hello World. Dopo aver configurato correttamente lambiente di sviluppo si pu procedere alla creazione di applicazioni semplicemente lanciando Eclipse e selezionando New->Android Project. Fatto ci comparir la seguente schermata in cui settare:
Project name: HelloWorld Application name: Hello World Package name: it.devapp.helloworld CreateActivity: HelloWorldActivity

31

Nel Building Target ci viene chiesto di scegliere con quale versione di Android lavorare mentre il campo Min SDK Version ci permette di settare la retro compatibilit con le versioni precedenti. In Create Activity viene chiesto di inserire il nome da assegnare alla Activity che Eclipse crea di default quando si scrive un nuovo progetto. Questo perch, come gi descritto nei capitoli precedenti, ogni programma Android deve contenere almeno una Activity.
Premendo su Finish, Eclipse crea diversi file, oltre alla Activity sopra descritta, organizzati in una struttura piuttosto ordinata come mostrato nella seguente figura.

AndroidManifest.xml:
il file che definisce i contenuti e il comportamento della nostra applicazione. In questo file XML si possono inserire nodi per ogni elemento (Activity, Service, Content Provider e cos via) che compone la nostra applicazione, impostando i permessi per determinare come questi interagiscono l'un l'altro e con le altre applicazioni. Ogni applicazione gira all'interno di un proprio processo Linux, per cui ci sono delle restrizioni ben specifiche: ogni processo non pu accedere alla memoria di un altro processo, e ad ogni applicazione assegnato uno specifico identificatore utente. Inoltre i file di un applicativo non possono essere letti o scritti da altri applicativi: anche l'accesso a diverse operazioni critiche sono protette, e dobbiamo specificatamente chiedere i permessi per utilizzarle. Questo tipo di richieste vanno impostate nell'AndroidManifest.xml .

32

Quando l'applicazione viene installata il gestore dei pacchetti concede o non concede i privilegi a seconda di come li abbiamo configurati nell'AndroidManifest.xml. Tra i principali permessi che possiamo richiedere ci sono i seguenti: READ_CONTACTS: leggere (ma non scrivere) i dati dei contatti dell'utente; WRITE_CONTACTS: scrivere (ma non leggere) i dati dei contatti dell'utente; RECEIVE_SMS: monitorare l'arrivo di messaggi SMS; INTERNET: accedere ed utilizzare la connessione Internet; ACCESS_FINE_LOCATION: utilizzare un accurato sistema di localizzazione come il GPS.

default.properties: poco rilevante per noi, poich serve esclusivamente al sistema di build automatico; src: contiene i package e le classi della nostra applicazione; assets: contiene risorse esterne necessarie allapplicazione (file audio, video, etc); res: contiene risorse esterne necessarie allapplicazione, ma in pi presenta una speciale struttura predefinita; contiene infatti a sua volta alcune sottocartelle: drawable-hdpi, drawable-ldpi e drawable-mdpi: contengono le immagini nelle 3 versioni per schermi a bassa densit, media densit e alta densit. layout: contiene il file main.xml utile per definire in modo dichiarativo il layout grafico dellapplicativo values: contiene il file strings.xml utilizzato per la localizzazione dellapplicativo gen: contiene la speciale classe chiamata R, abbreviazione di Resources. Invocando questa classe possibile richiamare via codice le risorse memorizzate sotto la directory res. La classe R viene generata automaticamente dal sistema e non deve mai essere modificata a mano.

Una volta compilato il progetto viene anche creata una cartella bin che conterr le classi compilate.

Significato e contenuto dei file principali AndroidManifest.xml


1 <?xml version="1.0" encoding="utf-8"?> 2 <manifest xmlns:android="http://schemas.android.com/apk/res/android" 3 package="it.devapp.helloworld" 4 android:versionCode="1" android:versionName="1.0"> 5 <uses-sdk android:minSdkVersion="4" /> 6 7 <application android:icon="@drawable/icon" android:label="@string/app_name"> 8 <activity android:name=".HelloWorldActivity" 9 android:label="@string/app_name"> 10 <intent-filter> 11 <action android:name="android.intent.action.MAIN" /> 12 <category android:name="android.intent.category.LAUNCHER" /> 13 </intent-filter> 14 </activity> 15 </application> 16

33

17 </manifest>

Come si vede in tale file ritroviamo alcune informazioni inserite nel template: la versione minima dellSDK, il package, la Activity di default, la application name. Questultima ha associata anche una etichetta che viene acceduta con la notazione @string/app_name, che fa si che venga reperito dal file strings.xml:

string.xml
1 <?xml version="1.0" encoding="utf-8"?> 2 <resources> 3 <string name="hello">Hello World, HelloWorldActivity!</string> 4 <string name="app_name">HelloWorld</string> 5

</resources>

il valore corrispondente ad app_name, ovvero HelloWorld. Android imposta per noi anche una icona di default, un caratteristico androide verde, anche questo acceduto con la notazione @drawable/icon, che dice ad Android di caricare una immagine che si chiama icon sotto la cartella res/drawable. Infine le righe
1 2 3 4

<intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter>

stabiliscono che la nostra Activity in grado di rispondere a intenti MAIN di category LAUNCHER: in parole povere che la nostra Activity il main lanciabile del nostro applicativo.

HelloWorldActivity.java
1 2 3 4 5 6 7 8 9 10 11 12 13 package it.devapp.helloworld; import android.app.Activity; import android.os.Bundle; public class HelloWorldActivity extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } }

Sostanzialmente tale programma non fa altro che lanciare lActivity principale, ossia mostrare una schermata il cui layout definito nel file main.xml.

34

main.xml
1 2 3 4 5 6 7 8 <?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android=http://schemas.android.com/apk/res/android android:layout_width="wrap_content" android:layout_height="wrap_content" android:orientation="vertical"> <TextView android:layout_width="fill_parent" android:text="@string/hello" android:layout_height="wrap_content"/> </LinearLayout>

In tale file viene definito il layout dellActivity. In particolare viene aggiunta una TextView che permette di scrivere su schermo il contenuto della stringa hello definita nel file string.xml.

35

Descrizione dellapplicazione TesinaTecAudio


Nel presente capitolo viene mostrato come creare una semplice applicazione Android capace di mostrare a video alcuni dati (latitudine, longitudine, altitudine e velocit) acquisiti tramite sistema GPS ed altri relativi allaccelerometro interno al dispositivo cellulare. Per il raggiungimento di tale obbiettivo si rivelato estremamente utile lutilizzo dei package android.location e android.hardware. Si proceder dunque ad una sommaria descrizione di questi, mentre una completa descrizione invece disponibile sul sito degli sviluppatori Android ai seguenti indirizzi: http://developer.android.com/reference/android/location/package-summary.html; http://developer.android.com/reference/android/hardware/package-summary.html.

Descrizione del package android.location


Package interamente dedicato alla localizzazione del dispositivo.

Interfacce
GpsStatus.Listener GpsStatus.NmeaListener LocationListener Usata per ricevere notifica quando cambia lo stato del GPS. Usata per ricevere stringhe NMEA dal GPS. Usata per ricevere notifica dal LocatioManager quando la posizione del dispositivo cambiata.

Classi
Address Criteria Serve a rappresentare un indirizzo/localit. Serve ad indicare i criteri secondo i quali una applicazione deve selezionare un location provider. Usata per la gestione della geocodifica e geodecodifica. Restituisce informazioni sul satellite GPS (es. azimuth, elevazione, ecc..). Rappresenta lo stato corrente del motore GPS (es. n di satelliti). Serve a rappresentare una posizione geografica rilevata in un dato istante (fix) . Consente laccesso ai servizi di localizzazione (es. avvertire quando si in prossimit di un dato fix) 36

Geocoder GpsSatellite GpsStatus Location LocationManager

LocationProvider

Una superclasse astratta per i location providers.

Ottenere la posizione del dispositivo Oltre alla pura elencazione delle classi e delle interfacce del package android.location vale la pena menzionare la procedura per ottenere la posizione del dispositivo tramite lutilizzo di tale package. Informazioni a riguardo sono disponibili alla pagina web http://developer.android.com/guide/topics/location/index.html i cui punti salienti vengono di seguito elencati:

1. creare un oggetto location Manager. Non possibile creare direttamente unistanza della classe
LocatioManager. Bisogna utilizzare la getSystemService(Context.LOCATION_SERVICE);; 2. creare unistanza della classe LocationListener ed utilizzare il metodo
public void onLocationChanged(Location location)

seguente

chiamata:

il quale crea unistanza della classe Location con i dati forniti dal GPS relativi allultima trasmissione ricevuta;

3. registrare il location Listener, creato al punto 2, al location Manager del punto 1 in modo da
permettere laggiornamento della posizione. Tale registrazione avviene tramite la seguente riga di codice :
locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListener);

I due parametri settati a zero sono relativi rispettivamente al tempo minimo di notifica e distanza minima di notifica. Il primo parametro, invece, imposta il tipo di provider utilizzato per la localizzazione (settare NETWORK_PROVIDER per lutilizzo della rete internet come provider);

4. Bisogna dichiarare nel file AndroidManifest.xml i permessi relativi allutilizzo del sistema GPS da
parte della nostra applicazione:
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> <uses-permission android:name="android.permission.ACCESS_GPS" /

37

Descrizione del package android.hardware

Interfacce
Camera.AutoFocusCallback Interfaccia di callback usata per notificare lavvenuta messa a fuoco automatica. Interfaccia di callback per la notifica degli errori Interfaccia di callback per la face detection nei frame. Interfaccia di callback per I cambiamenti di zoom durante operazioni di smooth zoom Interfaccia di callback usata per fornire i dati catturati in una immagine Interfaccia di callback usata per fornire anteprime di immagini Interfaccia di callback usata per fornire listante di cattura di una immagine Usata per ricevere notifica dal SensorManager quando i valori del sensore cambiano Classe deprecata. Usare SensorEventListener.

Camera.ErrorCallback Camera.FaceDetectionListener Camera.OnZoomChangeListener

Camera.PictureCallback

Camera.PreviewCallback Camera.ShutterCallback

SensorEventListener

SensorListener

Classi
Camera Classe utilizzata per settare le impostazioni di cattura delle immagini, start / stopanteprima, scattare foto, e recuperare i frame per la codifica il video. Camera.Area Classe usata per scegliere metriche ed areee di messa a fuoco per il calcolo di parametri come lesposizione, bilanciamento del bianco e lauto-focus . Informazioni sulla fotocamera Informazioni sullidentificazione dei volti tramite face detection

Camera.CameraInfo Camera.Face

38

Camera.Parameters Camera.Size GeomagneticField Sensor SensorEvent

Camera service settings. Riguarda le dimensioni dellimmagini Classe usata per stimare il campo magnetico. Classe utilizzata per rappresentare i sensori Rappresenta gli eventi dei sensori e viene utilizzata per acquisire informazioni dai sensori stessi (tipo di sensore, dati, accuratezza) Usato per accedere allutilizzo dei sensori

SensorManager

Ottenere i dati relativi al sensore Passi da seguire per effettuare una corretto utilizzo del sensore : 1. Implementare linterfaccia SensorEventListener;
public class TesinaTecAudioActivity extends Activity implements SensorEventListener{}

2. Creare unistanza della classe SensorManager al fine di poter accedere allutilizzo del sensore;
SensorManager mySensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);

3. Creare unistanza della classe Sensor e selezionarne il tipo di sensore;


Sensor Accelerometro = SensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

4. Registrare il sensore creato nel punto 3 come ascoltatore del SensorManager creato al punto 2;
mySensorManager.registerListener(this, Accelerometro, SensorManager.SENSOR_DELAY_NORMAL);

Lultimo parametro si riferisce al rate degli eventi di cambiamento di stato del sensore. 5. Utilizzare il metodo onSensorChanged per acquisire i dati dal sensore ad ogni cambiamento di stato di questultimo. Nel caso specifico dellaccelerometro i valori relativi allaccelerazione lungo i tre assi vengono forniti come un array di tre valori di tipo float. Altri esempi di sensori disponibili sono quelli relativi alla misurazione di pressione atmosferica, gravit rispetto ad altri pianeti, campo magnetico, ecc 39

Molto interessante anche il tipo di sensore che fornisce lorientazione in gradi rispetto al nord magnetico (azimuth,pitch e roll) e implementabile semplicemente modificando il punto 3 in Sensor.TYPE_ORIENTATION.

File sorgenti dellapplicazione TesinaTecAudio AndroidManifest.xml


<?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="esempio.TesinaTecAudio" android:versionCode="1" android:versionName="1.0"> <uses-sdk android:minSdkVersion="8" /> <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> <uses-permission android:name="android.permission.ACCESS_GPS" /> <application android:icon="@drawable/icon" android:label="@string/app_name"> <activity android:name=".TesinaTecAudioActivity" android:label="@string/app_name"> <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application> </manifest>

string.xml
<?xml version="1.0" encoding="utf-8"?> <resources> <string <string <string <string <string <string <string <string <string <string <string name="app_name">TesinaTecAudio</string> name="riga1">no valore</string> name="riga2">no valore</string> name="riga3">no valore</string> name="riga4">no valore</string> name="riga5">no valore</string> name="riga6">no valore</string> name="riga7">no valore</string> name="riga8">no valore</string> name="riga9">no valore</string> name="riga10">no valore</string>

</resources>

main.xml
<?xml version="1.0" encoding="utf-8"?> <TableLayout xmlns:android="http://schemas.android.com/apk/res/android"

40

android:stretchColumns="1" android:layout_height="wrap_content" android:layout_width="wrap_content"> <TableRow android:gravity="center"> <TextView android:textSize="20sp" android:text="DATI GPS" android:layout_width="wrap_content" android:gravity="center"></TextView> </TableRow> <View android:layout_height="2dip" android:background="#FF909090" /> <TableRow> <TextView android:textSize="15sp" android:gravity="left" android:padding="3dip" android:text="LATITUDINE"> </TextView> <TextView android:textSize="15sp" android:id="@+id/riga_1" android:gravity="right" android:padding="3dip" android:text="@string/riga1"> </TextView> </TableRow> <View android:layout_height="2dip" android:background="#FF909090" />

<TableRow> <TextView android:textSize="15sp" android:padding="3dip" android:text="LONGITUDINE"></TextView> <TextView android:text="@string/riga2" android:id="@+id/riga_2" android:gravity="right" android:textSize="15sp" android:padding="3dip" /> </TableRow> <View android:layout_height="2dip" android:background="#FF909090" />

<TableRow> <TextView android:textSize="15sp" android:padding="3dip" android:text="ALTITUDINE"></TextView> <TextView android:text="@string/riga3" android:id="@+id/riga_3" android:gravity="right" android:textSize="15sp" android:padding="3dip" /> </TableRow> <View android:layout_height="2dip" android:background="#FF909090" />

<TableRow> <TextView android:textSize="15sp" android:padding="3dip" android:text="VELOCITA'"></TextView> <TextView android:text="@string/riga4" android:id="@+id/riga_4" android:gravity="right" android:textSize="15sp"

41

android:padding="3dip" /> </TableRow> <View android:layout_height="2dip" android:background="#FF909090" />

<TableRow android:gravity="center"><TextView android:text="DATI ACCELEROMETRO" android:textSize="20sp" android:gravity="center"/> </TableRow> <View android:layout_height="2dip" android:background="#FF909090" />

<TableRow> <TextView android:textSize="15sp" android:padding="3dip" android:text="ASSE X:"></TextView> <TextView android:text="@string/riga5" android:id="@+id/riga_5" android:gravity="right" android:textSize="15sp" android:padding="3dip" /> </TableRow> <View android:layout_height="2dip" android:background="#FF909090" />

<TableRow> <TextView android:textSize="15sp" android:padding="3dip" android:text="ASSE Y:"></TextView> <TextView android:text="@string/riga6" android:id="@+id/riga_6" android:gravity="right" android:textSize="15sp" android:padding="3dip" /> </TableRow> <View android:layout_height="2dip" android:background="#FF909090" />

<TableRow> <TextView android:textSize="15sp" android:padding="3dip" android:text="ASSE Z:"></TextView> <TextView android:text="@string/riga7" android:id="@+id/riga_7" android:gravity="right" android:textSize="15sp" android:padding="3dip" /> </TableRow> <View android:layout_height="2dip" android:background="#FF909090" />

</TableLayout>

42

TesinaTecAudio.java
package esempio.TesinaTecAudio;

import import import import import import import import import import import

android.app.Activity; android.content.Context; android.hardware.Sensor; android.hardware.SensorEvent; android.hardware.SensorEventListener; android.hardware.SensorManager; android.location.Location; android.location.LocationListener; android.location.LocationManager; android.os.Bundle; android.widget.TextView;

public class TesinaTecAudioActivity extends Activity implements SensorEventListener{ /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); //--------------------------------- ISTRUZIONI RELATIVE AL GPS --------------------------------------------------------------------------LocationManager locationManager = (LocationManager) this.getSystemService(Context.LOCATION_SERVICE); final TextView lati = (TextView)this.findViewById(R.id.riga_1); final TextView longi = (TextView)this.findViewById(R.id.riga_2); final TextView alti = (TextView)this.findViewById(R.id.riga_3); final TextView velo = (TextView)this.findViewById(R.id.riga_4); LocationListener locationListener=new LocationListener(){ @Override public void onLocationChanged(Location location) { // TODO Auto-generated method stub Double geoLat = location.getLatitude(); Double geoLng = location.getLongitude(); lati.setText(Double.toString(geoLat)); longi.setText(Double.toString(geoLng)); Double altitu = location.getAltitude(); alti.setText(Double.toString(altitu)+"m"); Float veloci= location.getSpeed(); velo.setText(Float.toString(veloci)+"m/sec"); } @Override public void onProviderDisabled(String provider) { // TODO Auto-generated method stub } @Override public void onProviderEnabled(String provider) { // TODO Auto-generated method stub } @Override public void onStatusChanged(String provider, int status, Bundle extras) { // TODO Auto-generated method stub }};

43

locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0, locationListener); //------------------------------------ ISTRUZIONI RELATIVE ALL'ACCELEROMETRO ------------------------------------------------------------SensorManager mySensorManager = (SensorManager) getSystemService(SENSOR_SERVICE); Sensor Accelerometro = mySensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); mySensorManager.registerListener(this, Accelerometro, SensorManager.SENSOR_DELAY_NORMAL); } @Override public void onAccuracyChanged(Sensor sensor, int accuracy) { // TODO Auto-generated method stub } @Override public void onSensorChanged(SensorEvent event) { // TODO Auto-generated method stub TextView asseX=(TextView) this.findViewById(R.id.riga_5); TextView asseY=(TextView) this.findViewById(R.id.riga_6); TextView asseZ=(TextView) this.findViewById(R.id.riga_7); asseX.setText(Float.toString(event.values[0])); asseY.setText(Float.toString(event.values[1])); asseZ.setText(Float.toString(event.values[2])); } }

Di seguito viene riportata la schermata dellapplicazione creata cos come ci viene mostrata utilizzando il simulatore di eclipse.

Figura 9: Risultato dellapplicazione TesinaTecAudio

44

Sitorgrafia:
http://developer.android.com/reference/packages.html; http://android.devapp.it/category/tutorial-pratici; http://java.html.it/guide/; http://www.androiditaly.com/articoli/speciali/189-cose-android-la-storia-del-sistema-operativomobile-di-google.html; http://www.anddev.it/; http://www.tuttoandroid.net/android/il-futuro-della-medicina-con-android-11631/; http://www.beniculturali.it/mibac/export/MiBAC/sitoMiBAC/Contenuti/MibacUnif/Comunicati/visualizza_asset.html_198945880.html; http://www.beniculturali.it/mibac/opencms/MiBAC/sitoMiBAC/Contenuti/MibacUnif/Comunicati/visualizza_asset.html?id=75268&pagename=129; http://www.android-os.it/giochi/un-robot-controllato-da-android_3882; http://www.androidworld.it/2011/05/10/androidhome-il-framework-per-la-domotica-45961/; http://droid.cellularemagazine.it/2011/04/27/android-il-piu-desiderato-e-diffuso-damerica/; http://droid.cellularemagazine.it/2011/10/25/il-market-di-android-raggiunge-quota-500-mila-app/.

Bibliografia:

Cay S. Horstmann, Gary Cornell (2001) Java2: I fondamenti, McGraw-Hill, Milano; Android Programming (approfondimento tematico scaricabile dal sito http://puntoinformatico.it/PILibri/Dettaglio.aspx?id=238 ).

45