TESINA TECNICHE AUDIOVISIVE

5/14/2018 TESINA TECNICHE AUDIOVISIVE - slidepdf.com

http://slidepdf.com/reader/full/tesina-tecniche-audiovisive 1/45

Facoltà di Ingegneria

Corso di Laurea: Ingegneria delle Comunicacazioni

Cattedra: Tecniche Audiovisive

Titolo: “ Android: utilizzo del GPS e

dell’accelerometro”

Studente: Riccardo Russo

Matricola: 1044117

Anno accademico 2010/2011



2

SommarioAndroid: ............................................................................................................................................................. 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 l’ambiente 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 dell’applicazione “TesinaTecAudio” ............................................................................................ 36

Descrizione del packageandroid.location

................................................................................................... 36Ottenere la posizione del dispositivo ...................................................................................................... 37

Descrizione del package android.hardware ................................................................................................ 38

Ottenere i dati relativi al sensore ............................................................................................................ 39

File sorgenti dell’applicazione “TesinaTecAudio” ....................................................................................... 40

Sitorgrafia: ....................................................................................................................................................... 45

Bibliografia: ...................................................................................................................................................... 45



3

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. Quest’ultimo è anch'esso basato su Java e orientato agli oggetti, a sua volta esegu ito 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 milionidi 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++.

Dall’ottobre 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



4

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. Quest’ultimi possono reperire le varie

applicazioni nell’ Android Marcket ossia un “contenitore” di software online sviluppato da Google per i

dispositivi Android. Ciò avviene tramite l’utilizzo 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 l’Android Marcket conta più di 500.000 applicazioni di cui una grande parte è costituita dai

giochi, anche l’utilità e la complessità varia notevolmente. Si può passare da applicazioni che sfruttano i vari

sensori e funzioni del dispositivo come il GPS, l’accelerometro, 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 sul’Android 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 applicazionivengono 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 dell’Atac 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 dell’autovettura nella tratta di interesse.

Nel campo della medicina invece è possibili trovare veri e propri manuali su patologie, medicinali otecniche 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

http://it.wikipedia.org/wiki/Software

http://it.wikipedia.org/wiki/Google

http://it.wikipedia.org/wiki/Android


https://market.android.com/




http://it.wikipedia.org/wiki/Google

http://it.wikipedia.org/wiki/Software



5

dell’Imec e dell’Holst 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, l’attività celebrale, l’attività 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 l’invio di SMS,

trasmissione e-mail o l’utilizzo del GPS per individuare la posizione dell'utente qualora vengano misurati

valori anomali dei vari parametri monitorati. Nel suo complesso, l’intero sistema offre un duplice vantaggio:

una diminuzione dei costi dell’assistenza 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 l’applicazione “IOIO

Manager ” la quale consente di gestire una scheda IOIO. Quest’ultima è 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 sensoricon tutte le periferiche esterne collegabili a IOIO.



6

Figura 4 IOIO per Android

Un’altra 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”. Quest’ultima è un’applicazione gratuita che ricostruisce

virtualmente, in 3D ed in tempo reale, il Foro Romano in età costantiniana mentre si passeggia all’interno

dell’area 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 dell’utente,

consentendo una navigazione molto semplice ed intuitiva. Basta solamente puntare l’iPhone o l’iPad verso

un monumento per godersi un’ esperienza immersiva unica. Utilizzando un algoritmo software, infatti,

l’applicazione è in grado di riconoscere qualsiasi monumento georeferenziato intorno alla posizione

dell’utente e grazie a questa tecnica è possibile ascoltare l’audioguida 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.



7

Storia di Android

Dietro quello che sembra l’ennesimo successo della società di Mountain View, troviamo Andy Rubin e lasua 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 l’aggiunta 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

l’idea di uno smart-device con funzioni di telefonia incorporata, sulla falsa riga di quanto fatto da Microsoft

con Pocket PC 2002 Phone Edition, e l’ascesa 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 l’ambizione di realizzare in proprio un prodotto similare (in realtà non molto definito,

e senza sapere se investire sull’hardware, sul software o su entrambi).



8

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 l’azienda era alla ricerca di prodotti per estendere il proprio campo d’azione nel settore mobile.

Nello stesso anno arriva la svolta: Rubin, colpito dall’interessamento di Google, chiede di incontrare Page e,

durante il meeting, pronunciando la semplice frase: “Is this interesting to Google?”, segna l’inizio dell’eradell’ Androide.

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 l’esposizione 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 c’era Microsoft, la grande rivale, che stava cavalcando l’onda 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 edegli 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 l’intento 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 ) dell’Android Software Developer Kit e mettendo a disposizione 10 milioni di dollari per

coloro che realizzeranno le migliori applicazioni per il nuovo sistema.



9

Google è intenzionata a realizzare un ecosistema software che sia indipendente quanto più possibile

dall’hardware ed aperto al mondo degli sviluppatori. L’idea è quella di f ornire 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

dell’iPhone portò il 5% del traffico mondiale mobile sul motore di ricerca della società di Mountain View.

Ad agosto del 2008 è la volta dell’Android 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 possibilel’interazione 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 dell’immenso 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.



10

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 l’impossibilità 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 l’ambiente 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 mini-

torta 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 dell’atteso supporto al tastierino QWERTY virtuale, l’introduzione della

funzionalità di riconoscimento vocale e le nuove cartelle “live”. Altri piccoli/grandi accorgimenti

riguardano le performance del GPS, le API per lo sfruttamento dell’accelerometro da parte delle

applicazioni ed il supporto alla tecnologia Bluetooth Stereo.

Decisamente migliorati i Widget, ossia quelle piccole App attraverso cui ricevere costantementeinformazioni aggiornate dai propri canali preferiti, come, ad esempio, il servizio meteo. Ancora assenti le

API per l’utilizzo del Bluetooth all’interno delle proprie App.



11

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 all’interno 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%.



12

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 l’Agenda;

- 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, comele 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 all’apertura 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. L’aggiornamento 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 all’Engine V8 di Java. Con il primo le

applicazioni vengono lanciate più velocemente, così come l’intero sistema risponde in modo più fluido.

L’Engine Java V8, lo stesso presente su Chrome, rende l’esperienza Web con Froyo la più veloce nel settor e

degli OS mobile, grazie al browser integrato che carica in modo fulmineo le pagine web.



13

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 l’altro, richiedevano i

diritti di ROOT.

Froyo offre pieno supporto al FlashPlayer di Adobe, con performance di prim’ordine che permettono diriprodurre 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 l’auto-

update delle varie applicazioni installate (singolarmente o in modo cumulativo) ed un rinnovato sistema diricerca 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 all’introduzione 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 permetteuna più rapida correzione degli errori.



14

Le App-Game possono ora contare sui driver OpenGL ES, che sfruttano appieno l’hardware 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 l’Android 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à dell’APP acquistata/scaricata.

In sintesi, in Honeycomb troviamo:

http://www.storiainformatica.it/index.php?option=com_content&view=article&id=271%3Aandroid-23-gingerbread-pan-di-zenzero&catid=64&Itemid=94&lang=it




http://www.storiainformatica.it/index.php?option=com_content&view=article&id=272%3Aandroid-30-honeycomb-nido&catid=64&Itemid=94&lang=it








15

- Interfaccia disegnata per i tablet: un’interfaccia 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 quest’ultimo 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 veromultitasking, consentendo all’utente di visualizzare un’anteprima di tutte le applicazioni aperte nel

loro stato attuale e di passare velocemente da un “task” all’altro;

- Tastierino virtuale: Honeycomb ha un tastierino QWERTY virtuale ridisegnato per l’utilizzo 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 è l’ultima versione di Android, rilasciata nel mese di ottobre 2011.



16

Creare l’ambiente di sviluppo

Nel presente capitolo vengono elencati i software necessari alla creazione di applicazioni Android e la loromodalità 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 , l’AVD, per il quale è possibile scegliere sia la versione dell’SDK Android che la

memoria riservata sulla scheda SD del dispositivo.)

Passi da seguire per una corretta creazione dell’ambiente di sviluppo:

Scarichiamo e installiamo l’SDK 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, l’ultima versione di Java SDK è

la Java 7.

Scarichiamo e installiamo l’Android SDK

Visitiamo il sito degli sviluppatori Android all’indirizzo http://developer.android.com/sdk/index.html e

scarichiamo la versione per il nostro sistema operativo.

http://www.oracle.com/technetwork/java/javase/downloads/index.html



http://developer.android.com/sdk/index.html






17

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

installazione. Dopodichè lanciamo l’SDK 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

http://www.eclipse.org/downloads/






18

Nella dialog Add Repository che compare inseriamo “ADT Plugin” per il nome e l’url 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 .



19

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

Terminata l’installazione 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 l’Android 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.



20

Facciamo click su Apply .

Creiamo un AVD

Siamo ora pronti per creare un AVD. Avviamo l’AVD Manager e facciamo click suVirtual devices. Facciamo

click su New… e creiamo un nuovo dispositivo virtule come mostrato di seguito:



21

E’ ora possibile lanciare il dispositivo appena creato in emulazione:

Figura 6: Schermata principale del simulatore di Eclipse



22

Architettura di Android

Android non è una piattaforma hardware ma bensì un ambiente software progettato appositamente perdispositivi mobili. Nella figura seguente viene mostrata la stratificazione dell’architettura 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

l’hardware sottostante. Direttamente nel kernel, infatti, sono inseriti i driver per il controllo dell’hardware

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 all’astrazione dell’hardware, i livelli soprastanti non si

accorgono dei cambiamenti hardware, permettendo una programmazione ad alto livello omogenea eduna 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 dell’applicazione stessa in modo che solo quell’ID possa averne accesso. Inoltre, ogni applicazione sul

telefono viene lanciata in un processo Linux a sè stante all’interno della propria istanza della J ava 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:



23

• 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 nellamemoria 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 propriocore 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 interfaccegrafiche e previene eventuali problemi di accavallamento scoordinato sul display. E' uncomponente di vitale importanza per un terminale che fa delle interfacce grafiche un punto di forzadel suo funzionamento;

Open GL SE : è una libreria grafica, versione light della libreria OpenGL per terminali mobili, chepermette 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 perl'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 lapersistenza dei dati nelle varie applicazioni sviluppate;

• WebKit : browser engine open source (utilizzato anche per i più conosciuti browser web Safari eChrome). Da sottolineare che non si tratta di un browser web, quindi dovrà essere integrato nellediverse applicazioni;

• SSL: si tratta della famosa libreria per la gestione del Secure Socket Layer.



24

Android inserisce un layer di astrazione tra librerie di sistema ed il sistema operativo Linux per unificare casispecifici di comportamenti driver non standard e fornire un livello di separazione tra componenti Android esoftware GPL. L’intero Layer è sviluppato in C/C++ e definisce, per ogni tipologia di dispositivo,un’interfaccia di controllo da implementare in uno “stub” di comunicazione verso il driver Linux vero eproprio oppure, in genere, verso l’interfaccia esposta da una famiglia di driver.

L’ambiente di runtime è costituito invece da una libreria Core e da una macchina virtuale (VM): insiemecostituiscono la piattaforma di sviluppo per Android. La VM di Android (chiamata Dalvik) è una versioneparticolare della Java Virtual Machine, progettata e ottimizzata appositamente per girare su hardware nonperformanti, come quelli dei cellulari appunto. La Dalvik Virtual Machine esegue i files nel formato DalvikExecutable (.dex), generati a partire dal bytecode Java. I file .dex, hanno un tipo di compressione chepermette di dimezzare lo spazio utilizzato rispetto ai file .jar non compressi. Anche la Dalvik VirtualMachine, similmente per quanto accade per la JVM, implementa un Garbage Collector, liberando pertantolo 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. Quest’ultima è 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 "l’insieme 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 l’applicazione in esecuzione sul dispositivo Android viene eseguita

all’interno di una VM che è strettamente legata alle risorse del sistema operativo Linu x. Questo significa che

l’applicazione 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. L’architettura 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:



25

• 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 dalsistema;

• 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 dell’architettura Android citando la possibilità di scrivere codice

C/C++ in Android grazie all’ausilio 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: l’applicazione verrà creata come di consueto tramite le API della SDK, mentre qualchealgoritmo potrà essere delegato alla NDK tramite tramite la Java Native Interface (JNI) library.

http://developer.android.com/sdk/ndk/index.html


http://download.oracle.com/javase/6/docs/technotes/guides/jni/

http://download.oracle.com/javase/6/docs/technotes/guides/jni/




26

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 dell’interfaccia 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 , adesempio, 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.



27

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 un’applicazione deve ricevere e rispondere a un evento globale (arrivo di una

chiamata o di un SMS) deve registrarsi come Broadcast Receiver . Un’applicazione 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 l’utente è 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.



28

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 codiceresponsabile 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 l’utente. Di fatto, una Attività è una Classe che estende android.app.Activity. L’autore del codice,

realizzando l’attività, si serve dei metodi ereditati da Activity per controllare cosa appare nel display, per

assorbire gli input dall’utente, per intercettare i cambi di stato e per interagire con il sistema sottostante. Èpossibile mandare in esecuzione più attività simultaneamente, ma soltanto un’attività alla volta può

occupare il display. L’attività che occupa il display è in esecuzione e interagisce direttamente con l’utente.

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 un’attività può terminare sono due:

• L’attività è 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à.



29

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

l’attività viene creata. L’argomento savedInstanceState serve per riportare un eventuale statodell’attività salvato in precedenza da un’altra istanza che è stata terminata. L’argomento è null nelcaso in cui l’attività non abbia uno stato salvato;

• protected void onRestart(): richiamato per segnalare che l’attività sta venendo riavviata dopoessere stata precedentemente arrestata;

• protected void onStart(): richiamato per segnalare che l’attività sta per diventare visibile sulloschermo;

• protected void onResume(): richiamato per segnalare che l’attività sta per iniziare l’interazionecon l’utente;

• protected void onPause(): richiamato per segnalare che l’attività non sta più interagendo conl’utente;



30

• protected void onStop(): richiamato per segnalare che l’attività non è più visibile sullo schermo;

• protected void onDestroy(): richiamato per segnalare che l’applicazione sta per essere terminata.

le attività, attraverso un intent-filter, possono essere attivate in risposta ad uno specifico evento. Gli intent-

filter accettano figli di tre tipi:

• <action android:name="nome-azione"> individua gli intent che richiedono l’azione 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.

Un’attività dotata di un intent-filter che include l’azione android.intent.action.MAIN e la categoria

android.intent.category.LAUNCHER viene identificata come l’attività principale dell’applicazione. Ciò

significa che l’applicazione sarà elencata nel menù di sistema e che, quando l’utente l’avvierà, sarà lanciata

proprio l’attività marcata in tale maniera.

Un’applicazione Android può contenere più di un’attività. Una soltanto sarà marcata come attività

principale di lancio. Le altre saranno, invece, delle sotto-attività, che l’attività principale potrà lanciare

quando ce n’è bisogno. Realizzare una sotto-attività è semplice tanto quanto realizzare l’attività principale:

ancora una volta è sufficiente estendere android.app.Activity.

Le attività secondarie vanno poi registrate nel file AndroidManifest.xml, senza però applicare l’intent-filtercon l’azione e la categoria usate invece dall’attività principale. L’attività principale può lanciare delle sotto -

attività 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 solamentre 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 l’oggetto Intent contenente in messaggio. Il broadcast receiver viene considerato attivo solo

durante l’esecuzione del metodo onReceive(), quando questo metodo termina la sua esecuzione il receivertorna ad essere inattivo. Un processo che detiene un broadcast receiver attivo non può essere ucciso.



31

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 l’ambiente di sviluppo si può procedere alla creazione di applicazionisemplicemente 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



32

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 .



33

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 buildautomatico;

src : contiene i package e le classi della nostra applicazione;

assets: contiene risorse esterne necessarie all’applicazione (file audio, video, etc);

res: contiene risorse esterne necessarie all’applicazione, 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

dell’applicativo

values: contiene il file strings.xml utilizzato per la localizzazione dell’applicativo

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

12345678910111213

141516

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

package="it.devapp.helloworld" android:versionCode="1" android:versionName="1.0">

<uses-sdk android:minSdkVersion="4" />

<application android:icon="@drawable/icon" android:label="@string/app_name"> <activity android:name=".HelloWorldActivity"

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>



34

17 </manifest>

Come si vede in tale file ritroviamo alcune informazioni inserite nel template: la vers ione minima dell’SDK, il

package, la Activity di default, la application name. Quest’ultima 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

12345

<?xml version="1.0" encoding="utf-8"?> <resources>

<string name="hello"> Hello World, HelloWorldActivity! </string> <string name="app_name"> HelloWorld </string>

</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

1234

<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

123456

78910111213

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 l’Activity principale, ossia mostrare una

schermata il cui layout è definito nel file main.xml .



35

main.xml

123

45678

<?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"><TextViewandroid:layout_width="fill_parent"android:text="@string/hello" android:layout_height="wrap_content"/></LinearLayout>

In tale file viene definito il layout dell’Activity. In particolare viene aggiunta una TextView che permette di

scrivere su schermo il contenuto della stringa hello definita nel file string.xml.

http://schemas.android.com/apk/res/android

http://schemas.android.com/apk/res/android



36

Descrizione dell’applicazione “ 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

all’accelerometro interno al dispositivo cellulare. Per il raggiungimento di tale obbiettivo si è rivelato

estremamente utile l’utilizzo 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 Usata per ricevere notifica quando cambia lo stato del GPS.

GpsStatus.NmeaListener Usata per ricevere stringhe NMEA dal GPS.

LocationListener Usata per ricevere notifica dal LocatioManager quando la posizione deldispositivo è cambiata.

Classi

Address Serve a rappresentare un indirizzo/località.

Criteria Serve ad indicare i criteri secondo i quali una applicazione deve selezionare un

location provider.

Geocoder Usata per la gestione della geocodifica e geodecodifica.

GpsSatellite Restituisce informazioni sul satellite GPS (es. azimuth, elevazione, ecc..).

GpsStatus Rappresenta lo stato corrente del motore GPS (es. n° di satelliti).

Location Serve a rappresentare una posizione geografica rilevata in un dato istante (“fix”) .

LocationManager

Consente l’accesso ai servizi di localizzazione (es. avvertire quando si è in prossimitàdi un dato “fix”)

http://developer.android.com/reference/android/location/package-summary.html


http://developer.android.com/reference/android/hardware/package-summary.html


http://developer.android.com/reference/android/location/GpsStatus.Listener.html


http://developer.android.com/reference/android/location/GpsStatus.NmeaListener.html


http://developer.android.com/reference/android/location/LocationListener.html


http://developer.android.com/reference/android/location/Address.html


http://developer.android.com/reference/android/location/Criteria.html


http://developer.android.com/reference/android/location/Geocoder.html


http://developer.android.com/reference/android/location/GpsSatellite.html


http://developer.android.com/reference/android/location/GpsStatus.html


http://developer.android.com/reference/android/location/Location.html


http://developer.android.com/reference/android/location/LocationManager.html
















37

LocationProvider Una superclasse astratta per i location providers.

Ottenere la posizione del dispositivoOltre 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 l’utilizzo 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 un’istanza della classe

LocatioManager. Bisogna utilizzare la seguente chiamata:

“getSystemService(Context.LOCATION_SERVICE);”; 2. creare un’istanza della classe LocationListener ed utilizzare il metodo

public void onLocationChanged(Location location)

il quale crea un’istanza della classe Location con i dati forniti dal GPS relativi all’ultima trasmissione

ricevuta;

3. registrare il location Listener, creato al punto 2, al location Manager del punto 1 in modo da

permettere l’aggiornamento 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 l’utilizzo della rete internet come provider);

4.

Bisogna dichiarare nel file AndroidManifest.xml i permessi relativi all’utilizzo del sistema GPS daparte della nostra applicazione:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

<uses-permission android:name="android.permission.ACCESS_GPS" /

http://developer.android.com/reference/android/location/LocationProvider.html


http://developer.android.com/guide/topics/location/index.html


http://developer.android.com/reference/android/content/Context.html#getSystemService(java.lang.String)









38

Descrizione del package android.hardware

Interfacce

Camera.AutoFocusCallback Interfaccia di callback usata per notificare l’avvenuta messa a fuoco

automatica.

Camera.ErrorCallback Interfaccia di callback per la notifica degli errori

Camera.FaceDetectionListener Interfaccia di callback per la face detection nei frame.

Camera.OnZoomChangeListener Interfaccia di callback per I cambiamenti di zoom durante

operazioni di smooth zoom

Camera.PictureCallback Interfaccia di callback usata per fornire i dati catturati in una

immagine

Camera.PreviewCallback Interfaccia di callback usata per fornire anteprime di immagini

Camera.ShutterCallback Interfaccia di callback usata per fornire l’istante di cattura di una

immagine

SensorEventListener Usata per ricevere notifica dal SensorManager quando i valori del

sensore cambiano

SensorListener Classe deprecata. Usare SensorEventListener.

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 l’esposizione, bilanciamento del bianco e l’auto-focus .

Camera.CameraInfo Informazioni sulla fotocamera

Camera.Face Informazioni sull’identificazione dei volti tramite face detection

http://developer.android.com/reference/android/hardware/Camera.AutoFocusCallback.html


http://developer.android.com/reference/android/hardware/Camera.ErrorCallback.html


http://developer.android.com/reference/android/hardware/Camera.FaceDetectionListener.html


http://developer.android.com/reference/android/hardware/Camera.OnZoomChangeListener.html


http://developer.android.com/reference/android/hardware/Camera.PictureCallback.html


http://developer.android.com/reference/android/hardware/Camera.PreviewCallback.html


http://developer.android.com/reference/android/hardware/Camera.ShutterCallback.html


http://developer.android.com/reference/android/hardware/SensorEventListener.html


http://developer.android.com/reference/android/hardware/SensorListener.html




http://developer.android.com/reference/android/hardware/Camera.html


http://developer.android.com/reference/android/hardware/Camera.Area.html


http://developer.android.com/reference/android/hardware/Camera.CameraInfo.html


http://developer.android.com/reference/android/hardware/Camera.Face.html


















39

Camera.Parameters Camera service settings.

Camera.Size Riguarda le dimensioni dell’immagini

GeomagneticField Classe usata per stimare il campo magnetico.

Sensor Classe utilizzata per rappresentare i sensori

SensorEvent Rappresenta gli eventi dei sensori e viene utilizzata per acquisire informazioni

dai sensori stessi (tipo di sensore, dati, accuratezza)

SensorManager Usato per accedere all’utilizzo dei sensori

Ottenere i dati relativi al sensorePassi da seguire per effettuare una corretto utilizzo del sensore :

1. Implementare l’interfaccia “SensorEventListener ”;

public class TesinaTecAudioActivity extends Activity implements

SensorEventListener{…}

2. Creare un’istanza della classe “Sensor Manager” al fine di poter accedere all’utilizzo del sensore;

SensorManager mySensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);

3. Creare un’istanza 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);

L’ultimo 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 quest’ultimo. Nel caso specifico dell’accelerometro i valori relativi all’accelerazione 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…

http://developer.android.com/reference/android/hardware/Camera.Parameters.html


http://developer.android.com/reference/android/hardware/Camera.Size.html


http://developer.android.com/reference/android/hardware/GeomagneticField.html


http://developer.android.com/reference/android/hardware/Sensor.html


http://developer.android.com/reference/android/hardware/SensorEvent.html


http://developer.android.com/reference/android/hardware/SensorManager.html










40

Molto interessante anche il tipo di sensore che fornisce l’orientazione in gradi rispetto al nord magnetico

(azimuth,pitch e roll) e implementabile semplicemente modificando il punto 3 in

…Sensor.TYPE_ORIENTATION .

File sorgenti dell’applicazione “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 name="app_name">TesinaTecAudio</string>

<string name="riga1">no valore</string>

<string name="riga2">no valore</string> <string name="riga3">no valore</string>






</resources>

main.xml<?xml version="1.0" encoding="utf-8"?>

<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"



41

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>


<TableRow> <TextView android:textSize="15sp" android:padding="3dip"

android:text="LONGITUDINE"></TextView>

<TextView

android:text="@string/riga2"



android:padding="3dip" /> </TableRow>


<TableRow>

<TextView android:textSize="15sp" android:padding="3dip" android:text="ALTITUDINE"></TextView>

<TextView






<TableRow>

<TextView android:textSize="15sp" android:padding="3dip"

android:text="VELOCITA'"></TextView> <TextView


android:id="@+id/riga_4" android:gravity="right" android:textSize="15sp"



42

android:padding="3dip" />

</TableRow>


<TableRow android:gravity="center"><TextView android:text="DATI ACCELEROMETRO"

android:textSize="20sp" android:gravity="center"/> </TableRow>


<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>


<TableRow>

<TextView android:textSize="15sp" android:padding="3dip" android:text="ASSE

Y:"></TextView>

<TextView android:text="@string/riga6"

android:id="@+id/riga_6"





<TableRow>

<TextView android:textSize="15sp" android:padding="3dip" android:text="ASSE

Z:"></TextView> <TextView

android:text="@string/riga7" android:id="@+id/riga_7"





</TableLayout>



43

TesinaTecAudio.java

package esempio.TesinaTecAudio;

import android.app.Activity;

import android.content.Context;

import android.hardware.Sensor;import android.hardware.SensorEvent;

import android.hardware.SensorEventListener;

import android.hardware.SensorManager;

import android.location.Location;

import android.location.LocationListener;

import android.location.LocationManager;import android.os.Bundle;

import 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) {


}

@Override

public void onStatusChanged(String provider, int status,

Bundle extras) {


}};



44

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) {


}

@Override

public void onSensorChanged(SensorEvent event) {


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 dell’applicazione creata così come ci viene mostrata utilizzando il

simulatore di eclipse.

Figura 9: Risultato dell’applicazione “TesinaTecAudio”



45

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-operativo-

mobile-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/sito-

MiBAC/Contenuti/MibacUnif/Comunicati/visualizza_asset.html_198945880.html;

- http://www.beniculturali.it/mibac/opencms/MiBAC/sito-

MiBAC/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://punto-

informatico.it/PILibri/Dettaglio.aspx?id=238 ).

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-operativo-mobile-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/sito-MiBAC/Contenuti/MibacUnif/Comunicati/visualizza_asset.html_198945880.html



http://www.beniculturali.it/mibac/opencms/MiBAC/sito-MiBAC/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/


http://punto-informatico.it/PILibri/Dettaglio.aspx?id=238




















TESINA TECNICHE AUDIOVISIVE

Documents

Transcript of TESINA TECNICHE AUDIOVISIVE