Sistemi Embedded per il Mobile Multimedia
La piattaforma Android
[email protected]
[email protected]
Bibliografia
Free
●
http://developer.android.com/
●
http://punto-informatico.it/PILibri/Dettaglio.aspx?id=238
Books
●
Android Guida per lo Sviluppatore, APOGEO
●
Beginning Android 3, APRESS
●
Advanced Android Development, MURPHY
Agenda
●
●
●
●
Introduzione ad Android: contesto, storia e
confronto con altre piattaforme, caratteristiche
Architettura: Applicazioni, Application
Framework, Librerie, Android Runtime, ...
Dalvik Virtual Machine: confronto con JVM,
gestione della memoria, bytecode
Strumenti di Sviluppo: SDK, Emulator
SISTEMI EMBEDDED
Lezione n. 1:
Introduzione ad Android
La rivoluzione dei dispositivi mobili 1/2
Il dispositivo che fino a qualche anno fa
chiamavamo cellulare oggi è a tutti gli effetti un
Personal Computer.
La vera rivoluzione dal punto di vista degli utenti
consiste nel fatto che uno smartphone è molto più
Personal di un PC perché ci segue ovunque.
Gli sviluppatori possono finalmente creare
applicazioni che non devono fare più i conti con il
concetto di "risorse limitate".
5
La rivoluzione dei dispositivi mobili 2/2
Dal punto di vista dei produttori la rivoluzione
consiste nel fatto che in passato ogni produttore
di dispositivi mobili ha realizzato un proprio
sistema operativo, ambiente di sviluppo,
linguaggio, tool: nessuno si è affermato come
standard.
Il progetto Android nasce quindi da una esigenza
di standardizzazione su iniziativa di Google.
http://www.android.com/
6s
Cosa è Android?
Android è la prima piattaforma software open per
dispositivi mobile
Android è uno stack software per dispositivi mobili
ed include un sistema operativo, un middleware
ed un insieme di applicazioni chiave.
Android è stato sviluppato da Google Inc. e da un
consorzio di aziende chiamato Open Handset
Alliance
7
Perchè Open?
E' open perchè:
●
●
Utilizza tecnologie open (linux kernel)
Le librerie e le API utilizzate per realizzare Android
sono le stesse che possiamo usare per le nostre
applicazioni
Il kernel linux è rilasciato sotto GNU General
Personal Licence (GPL).
La piattaforma Android è rilasciata sotto Open
Source Apache Software Licence 2.0 (ASL).
8
Open Handset Alliance
http://www.openhandsetalliance.com
●
Operatori mobili: Telecom, Vodafone, T-Mobile...
●
Produttori di chip: Arm, Intel, NVIDIA...
●
●
●
Produttori di telefonini: Toshiba, HTC, Acer,
Sony,...
Aziende sviluppatrici di software: Google, eBay,
Omron, ...
Aziende di commercializzazione: Accenture,
Aplix...
9
Un po' di storia
10
G1 T-Mobile
Processor Qualcomm®
MSM7201A™, 528 MHz
RAM: 192 MB
Storage: Flash Memory 256 MB
Display 3.2''
Supporto 3G UMTS/HSDPA a
7,2 Mbps
11
Platforms 1/2
12
Platforms 2/2
Fonte: developer.android.com Aggiornato al 01/10/2012
13
Requisiti Minimi 1/2
I requisiti minimi di ogni versione rilasciata, sono
definiti mediante l'Android Compatibility Program
che consiste di tre componenti chiave:
Il codice sorgente dello stack software Android
● Il “Compatilbility Definition Document”, che
descrive le specifiche di compatibilità
● La “Compatilbility Test Suite”, che rappresenta il
"meccanismo" di compatibilità
● I più recenti ACP si riferiscono alla 4.0.3 e alla
2.3
●
14
Requisiti Minimi 2/2
Per Android 2.2 alcuni dei requisiti minimi sono:
Memoria >= 128MB (kernel) + 150MB (/data) +
1GB (Application/SD Card)
FotoCamera >= 2 megapixel
Display >= 2,5''
Per Android 4.0 alcuni dei requisiti minimi sono:
Memoria >= 340MB (kernel) + 350MB (/data) +
1GB (Application/SD Card)
FotoCamera >= 2 megapixel
Display >= 2,5''
15
Codice Sorgente di Android
●
●
●
Il codice sorgente di Android può essere
scaricato seguendo le indicazioni descritte in
http://source.android.com/source/downloading.html
Le ultime versioni di Android per le quali è
disponibile il codice sorgente sono la 4.0 (API
level 14) e la 2.3 (API level 9)
16
Caratteristiche principali 1/3
●
●
●
●
Android include un ”application framework” che
permette il riutilizzo dei componenti sviluppati.
La Dalvik Virtual Machine è ottimizzata per
l'esecuzione su dispositivi mobili.
Il browser web integrato è basato sul software
open-source ”WebKit”.
La grafica 2D è basata su una libreria
appositamente sviluppata.
17
Caratteristiche principali (2/3)
●
●
●
●
La grafica 3D è basata sulla specifica OpenGL
ES 1.0 e l'accelerazione hardware è opzionale.
Per l'immagazzinamento strutturato di dati si
usa SQLite.
Sono supportati i più comuni formati audio e
video (MPEG4, H.264, MP3, AAC, AMR, JPG,
PNG, GIF).
Supporta la telefonia GSM.
18
Caratteristiche principali (3/3)
●
●
●
A seconda dell'hardware può supportare anche
EDGE (2.5G), UMTS (3G), Bluetooth e Wi-Fi.
Prevede anche il supporto per fotocamera,
GPS, bussola e accelerometro.
Fornisce un ricco ambiente integrato di sviluppo
che include un emulatore, strumenti per il
debugging e per il profiling di memoria e
prestazioni, ed un plugin per l'IDE Eclipse per
sviluppare applicazioni in linguaggio Java.
19
Architettura di Android
20
Componenti del sistema
I componenti mostrati nel precedente schema
dell'architettura verranno ora analizzati uno ad uno:
●
Applicazioni
●
Application Framework
●
Librerie
●
Android Runtime
●
Kernel Linux
21
Applicazioni
Android dispone di base di un insieme di
applicazioni che includono un client email,
un programma per la gestione degli SMS,
agenda, rubrica, mappe, un browser web e
altre.
Tutte le applicazioni vengono scritte
utilizzando il linguaggio di programmazione
Java.
22
Application Framework
●
●
●
●
Gli sviluppatori hanno pieno accesso alle
stesse API del framework che vengono
utilizzate dalle applicazioni di base.
L'architettura delle applicazioni è progettata per
semplificare il riutilizzo dei componenti.
Ogni applicazione può pubblicare le sue
capabilities e le altre possono farne uso.
Questo stesso meccanismo fa sì che l'utente
possa rimpiazzare alcuni componenti.
23
Servizi dell'Application Framework (1/2)
L'Application Framework fornisce alle applicazioni
i seguenti servizi:
●
●
Un insieme di Views completo ed estensibile
che include liste, griglie, text-box, pulsanti e
perfino un browser web integrato
nell'applicazione.
I Content Provider permettono alle
applicazioni di accedere ai dati di altre
applicazioni (es. la rubrica) o di mettere in
condivisione i loro stessi dati.
24
Servizi dell'Application Framework (2/2)
●
●
●
Un Resource Manager che fornisce l'accesso
alle risorse esterne al codice, come stringhe
localizzate, grafici e file di layout.
Un Notification Manager permette a tutte le
applicazioni di mostrare avvisi personalizzati
sulla barra di stato.
Un Activity Manager che gestisce il ciclo di vita
delle applicazioni.
25
Librerie Native (1/4)
●
●
●
Sono librerie scritte in C/C++ che
rappresentano il core di Android e sono usate
dai vari componenti del sistema.
Le capabilities di queste librerie sono esposte
agli sviluppatori sempre attraverso l'Application
Framework.
La libreria più importante è senz'altro la
Standard C Library (libc) derivata dalla sua
implementazione BSD e ottimizzata per
l'esecuzione su dispositivi embedded.
26
Librerie Native (2/4)
●
●
Il Media Framework (librerie multimediali) sono
basate su OpenCORE di PacketVideo e
supportano la riproduzione e la registrazione di
vari formati audio/video.
Il Surface Manager gestisce l'accesso al
sottosistema di visualizzazione su schermo e
senza sforzo da parte del programmatore
compone livelli di grafica 2D e 3D provenienti
da varie applicazioni.
27
Librerie Native (3/4)
●
●
●
WebKit (LibWebCore) è il motore di browser
alla base sia del browser principale di Android
che delle web view integrate nelle applicazioni.
SGL è l'engine grafico 2D.
Le librerie 3D implementano la API OpenGL
ES 1.0 e 2.0 e possono utilizzare sia
l'accelerazione hardware (se disponibile) sia
una implementazione software ottimizzata.
28
Librerie Native (4/4)
●
●
●
La liberia FreeType fornisce il rendering per i
font bitmap e vettoriali
SQLite è un potente e leggero motore di
database relazionale disponibile per tutte le
applicazioni, per la memorizzazione di qualsiasi
tipo di dato strutturato
SSL è la libreria per la gestione dei Secure
Socket Layer.
29
Android Runtime
●
●
●
L'Android Runtime si compone delle Core
Libraries e della Dalvik Virtual Machine.
Le Core Libraries forniscono molte delle
funzionalità delle analoghe librerie disponibili
per il linguaggio di programmazione Java.
Ogni applicazione Android gira in un suo
proprio processo, con la sua istanza della
Dalvik Virtual Machine (VM).
30
Core Libraries
●
●
Rappresentano un insieme di librerie molto ”vicine”
alla Dalvik Virtual Machine ed estratte in parte dal
progetto Apache Harmony (2007) ed in parte
appositamente adattate
Sono distribuite in tre categorie:
●
DalvikVM specific libraries (System Info, Debugging)
●
Java Compatibility libraries (Base and utility classes)
●
Thirty Part Libraries (Apache HttpClient 4.0)
31
Dalvik VM (1/2)
●
●
●
La Dalvik VM è stata ottimizzata in modo che
uno stesso dispositivo embedded sia in grado
di eseguirne più istanze in modo efficiente.
La Dalvik VM esegue un bytecode
incompatibile con quello della Java VM e che
viene detto Dalvik Executable (.dex),
ottimizzato per avere una occupazione di
memoria minima.
La Dalvik VM è register-based (mentre la Java
VM è stack-based).
32
Dalvik VM (2/2)
Il ciclo di sviluppo prevede
che una applicazione venga
dapprima sviluppata in
Java, e successivamente
un tool (dx) converte i file
.class, ottenuti dalla
normale compilazione java,
in file ottimizzati .dex
33
Kernel Linux
●
●
Android si basa sul kernel Linux (la versione 4.1
è basata sul kernel 3.1.10) per i servizi di base
come la sicurezza, la gestione della memoria,
la gestione dei processi, lo stack di rete e il
modello dei driver.
Il kernel funge anche da livello di astrazione tra
l'hardware e il resto dello stack software. In
questo livello avviene la gestione dei driver
dell'hardware (videocamera, display, memoria
flash, la scheda wireless...)
34
Conclusioni
In questa lezione abbiamo visto una prima panoramica di
Android, le sue caratteristiche principali e le varie parti
che compongono la sua architettura.
35
Sistemi Embedded - Android
Lezione n. 2:
Piattaforme per Dispositivi
Mobili
Piattaforme per dispositivi mobili (Passato)
Fino ai primi anni 90 non si può
parlare di piattaforme ma di Sistemi Embedded
● 1996
●
●
●
Palm OS
●
Windows CE
2000
●
Symbian
●
Windows Pocket PC
2006
●
Java ME
37
Piattaforme per dispositivi mobili (Presente)
Attualmente le più diffuse piattaforme per
dispositivi mobili sono:
●
Windows Phone 7
●
iOS 6
●
Blackberry (Java ME + API BlackBerry)
●
Android
38
Mercato USA Gen-Mar 2012
fonte: comscore.com
39
Previsione Mercato USA 2015
fonte: gartner's
40
Previsione mondiale 2011-2015
fonte: idc.com
41
Blackberry
●
●
●
I telefoni Blackberry di RIM (Research-InMotion) sono prodotti diffusi da anni nell'ambito
enterprise.
Sono specializzati nella gestione della posta
elettronica in modalità ”push”.
Sebbene siano sempre considerati prodotti
all'avanguardia, sono sempre stati utilizzati solo
nell'ambito aziendale e non hanno quindi avuto
una grande diffusione nel mercato consumer
che garantisce i volumi più elevati.
42
Sistemi Operativi per Smartphone
●
●
●
Di conseguenza nei prossimi anni la vera lotta tra i
sistemi operativi per smartphone avverrà fra quattro
grandi concorrenti: Windows Phone, iOS e Android.
Dietro questi sistemi operativi si celano i colossi del
mondo IT, ovvero Microsoft, Apple, Google, Nokia(?),
Samsung .
Seguendo l'esempio di Google anche Nokia ha
dichiarato che ben presto anche Symbian diventerà
open-source (come conseguenza all'allenza con
Microsoft).
43
Confronto tra SO:strumenti di sviluppo
●
●
Per tutte le piattaforme prese in considerazione
l'SDK che permette lo sviluppo di applicazioni è
liberamenente disponibile.
Riguardo ai linguaggi di programmazione da
adoperare, per Windows Mobile è possibile
utilizzare indifferentemente C++, C# e VB.NET.
●
Per Symbian si usa C++.
●
Per iOS si usa Objective-C.
●
Per Android e BlackBerry si usa Java.
44
Confronto tra SO: distribuzione applicazioni
●
●
Tutte le piattaforme provedono: un App Store
ufficiale (Apple-iTunes App Store, Android Market,
Nokia-Ovi Store, Windows Phone MarketPlace e
BlackBerry-App World) dal quale è possibile
scaricare programmi gratuiti o a pagamento.
L'installazione tramite PC è prevista da Windows
mediante il WMDC, Nokia con il Nokia OVI Suite,
Android Platform per Android e BlackBerry
mediante il Desktop Manager .
45
Piattaforme Mobile in arrivo
●
Open Source – Linux based
●
Open Source – Linux based
●
Closed Source, Cloud based
– Android Fork
46
Conclusioni
In questa lezione abbiamo elencato le principali
piattaforme alternative per lo sviluppo di
applicazioni per terminali mobili.
47
Sistemi Embedded - Android
Lezione n. 3:
Android VS Java
Introduzione
In questa lezione vedremo quali sono le differenze principali tra
Android e le varie versioni di Java.
Linguaggio Java e VM
●
●
Quando si parla di Java bisogna subito chiarire
se ci si riferisce al linguaggio di
programmazione oppure alle varie versioni di
librerie e Virtual Machine.
Dal punto di vista del linguaggio di
programmazione, Android si basa al 100% sul
linguaggio di programmazione Java ed in
particolare richiede la presenza del JDK 5 o 6
per permettere lo sviluppo con Eclipse o altri
IDE.
Versioni di Java 1/2
JAVA EE
Enterprise
Edition
JAVA SE
Standard
Edition
JAVA ME
Connected
JAVA ME
Limited
(CDC)
(CLDC)
per la creazione
di servlet per il
mondo dei web
service
per la
creazione di
applet e
applicazioni per
il mondo
desktop
per la
creazione di
Xlet per
dipositivi
mobile
sempre
connessi
per la creazione di
Midlet per
dispositivi mobile
limitatamente
connessi
CDC = Connected Device Configuration
CLDC = Connected Limited Device Configuration
Non solo Java
Google fornisce agli sviluppatori due ulteriori
strumenti per lo sviluppo di applicazioni:
●
●
Scripting Layer for Android (SL4A):
supporto ai più diffusi linguaggi di script
(JavaScript, Python, Perl, JRuby, Lua) per
lo sviluppo di applicazioni
Android Native Development Kit (NDK):
sviluppo di applicazioni in codice nativo
(C/C++)
Versioni di Java 2/2
Processori da 32bit
Memoria da 2MB +
2,5MB
JVM
KVM
JAVA
JAVAME
MECDC
CDC
JAVA
JAVAME
MECLDC
CLDC
>= 512 KB
>= 128 KB
Memoria
java
>= 256 KB
>= 32 KB
Memoria
runtime
JAVA
JAVAEE
EE
Enterprise
Enterprise
Edition
Edition
JAVA
JAVASE
SE
Standard
Standard
Edition
Edition
Processori da 16bit
Memoria da 40Kb +
20Kb
API Java
Java EE
Java SE
Java ME
CDC
Java ME
CLDC
CDC e CLDC possono
supportare API Java
esterne a Java SE.
Come conseguenza si
potrebbe avere un
programma Java che
viene eseguito
correttamente su
Desktop, ma non vi
sono garanzie che sia
eseguito anche su
dispositivi che
supportano solo ME
JavaME e Android 1/3
●
●
Configurazioni: JavaME supporta due classi di
micro-dispositivi e offre soluzioni standardizzate
per ognuna di esse . Android supporta una sola
classe e non è possibile eseguirlo su dispositivi
”limitati”
Comprensibilità: Android è pensato per un
unico modello di dispositivo e quindi utilizza una
UI ”adattabile”. JavaMe dispone di modelli di UI
differenti per device: MIDlets, Xlets, AWT e
Swing: include più di 20 JSR (Java
Specification Request)
JavaME e Android 2/3
●
●
Reattività: La DVM è maggiormente ottimizzata
e più reattiva se paragonata alla JVM su uno
stesso dispositivo. In realità dovremmo
paragonare la DVM alla KVM ma ciò non è
possibile perchè questa è pensata per
dispositivi di basso profilo.
Compatibilità con JAVA: a causa della DVM,
Android esegue solo bytecode .dex e non java:
è sempre possibile compilare il codice Java in
standard Java Class, pur non essendo possibile
eseguirne direttamente il bytecode.
JavaME e Android 3/3
●
●
Scelta: JavaME è ampliamente supportato in
quanto diffuso su moltissimi dispositivi mobili,
ma l'uniformità, il costo e la facilità nello
sviluppo fanno migrare ogni giorno molti
programmatori Java verso Android.
Supporto JavaSE: se paragonato al supporto di
JAVAME-CDC, il supporto di Android a JavaSE
è più completo, fatta eccezione per AWT e
Swing.
Android e Dalvik VM
●
●
Google ha quindi preso un sottoinsieme delle
librerie JAVA, (poi delle Apache Harmony 2007), ha aggiunto alcuni propri package
specifici per l'utilizzo in dispositivi mobili e ha
definito un proprio formato bytecode ottimizzato
per ridurre al minimo l'occupazione di memoria.
La macchina virtuale in grado di eseguire
questo bytecode come detto si chiama Dalvik
VM, e non essendo una macchina virtuale Java
ME non è previsto il pagamento di nessuna
royalty.
Confronto tra le API
●
●
●
Cercheremo adesso di fare un rapido confronto
tra le API di Java SE e quelle di Android.
Elencheremo prima quelle supportate anche in
Android che possono essere quindi utilizzate
senza modificare eventuale codice già scritto in
linguaggio Java.
Successivamente elencheremo quelle che sono
state rimosse e magari sostituite da altre
ritenute migliori.
API estese di Java SE supportate in Android
●
javax.crypto
●
javax.net
●
javax.security
●
javax.sound
●
javax.sql
●
javax.xml.parsers
●
org.w3c.dom (tranne i sotto-package)
●
org.xml.sax
API di Java SE NON supportate in Android 1/2
●
java.applet
●
java.awt
●
java.beans
●
java.lang.management
●
java.rmi
API estese di Java SE NON supportate in Android (1/2)
●
javax.accessibility
●
javax.activity
●
javax.imageio
●
javax.management
●
javax.naming
●
javax.print
●
javax.rmi
●
javax.security.auth.kerberos
●
javax.security.auth.spi
●
javax.security.sasl
API estese di Java SE NON supportate in Android (2/2)
●
javax.swing
●
javax.transaction
●
javax.xml (tranne javax.xml.parsers)
●
org.ietf.*
●
org.omg.*
●
org.w3c.dom.* (i sotto-package)
Java ME
●
●
●
Java ME viene attualmente considerato quasi
obsoleto, in quanto presenta potenzialità molto
ridotte e non supporta molte delle tecnologie
che sono state sviluppate negli ultimi anni.
Sebbene sia stato sviluppato da Sun
Microsystems con molte ambizioni, non è mai
riuscito ad uscire dalla nicchia dei videogiochi.
Non viene considerato un sistema operativo per
”smartphone”, ovvero telefoni con funzionalità
simili a quelle di un PC.
Conclusioni
In questa lezione abbiamo visto le differenze principali le API di
Java e quelle di Android.
Sistemi Embedded - Android
Lezione n. 4:
La macchina virtuale Dalvik
SEMM2013
Introduzione
In questa lezione tratteremo della macchina
virtuale Dalvik, ottimizzata da Google per
l'esecuzione su dispositivi mobili.
SEMM2013
Perché una VM?
●
●
●
Quando nacque Java venne coniato lo slogan
”Write once, run everywhere”, ovvero ”scrivi il
programma una volta e poi lo esegui su
qualunque dispositivo”.
Questo avviene perché la macchina virtuale è
uno strato software che astrae l'hardware
sottostante, mettendo a disposizione del
bytecode una macchina sempre uguale.
Android, come anticipato usa un approccio
simile, e la sua VM si chiama Dalvik.
SEMM2013
Requisiti per Dalvik
●
●
La Dalvik VM è stata progettata da Dan
Bornstein, ingegnere di Google originario della
città di Dalvik in Islanda.
I requisiti che a Dan Bornstein sono stati
imposti per la progettazione di questa Virtual
Machine sono stati la capacità di girare su un
sistema con una CPU lenta, con poca memoria,
con un sistema operativo senza area di swap e
il tutto alimentato solo da una batteria ed un
application runtime di tipo “sandbox”.
SEMM2013
Il problema della memoria
●
●
●
Inizialmente, nella progettazione della DVM, si
è supposto di avere a disposizione un tipico
smartphone con soli 64 MByte di memoria.
Questo spazio dopo l'avvio del kernel Linux si
riduce a 40 MByte, che diventano 20 dopo
l'avvio dei servizi di alto livello.
Si è visto inoltre che la libreria C standard (libc)
è molto vasta e occupa circa 10 Mbyte.
SEMM2013
Java versus Dalvik
fonte: oreilly.com
SEMM2013
Dalvik Executable
●
Un primo lavoro che è stato fatto è stato quello
di specificare un formato (dex o Dalvik
Executable) in grado di risparmiare spazio
rispetto al bytecode di Java:
SEMM2013
Confronto tra bytecode
●
●
●
Utilizzando questo nuovo formato si ottengono
già dimensioni del bytecode molto ridotte.
Ad esempio le librerie di sistema, rispetto al
100% originario, diventano grandi il 50%
quando compresse da Java in formato JAR e
48% in formato dex non compresso (non
richiede decompressione).
L'applicazione browser passa invece dal 100%
originario e 49% compresso in JAR a solo il
44% in formato dex non compresso.
SEMM2013
Separazione della memoria
●
●
●
●
Un altro accorgimento adottato in Dalvik
rispetto a Java è la separazione della memoria
nel momento in cui avviene una chiamata di
sistema fork().
A differenza di quanto accade in Java, ogni
applicazione Android ha un proprio processo ed
una propria istanza della DVM.
La DVM è stato progettata in modo tale che un
dispositivo possa eseguire molte VM in maniera
efficiente.
Anche il meccanismo di Garbage Collector di
ogni applicazione deve essere indipendente.
SEMM2013
Efficienza
●
●
●
Per quanto riguarda la CPU si è supposta una
frequenza compresa fra i 250 e i 500 MHz, con
un bus di sistema a 100 MHz e una cache dati
di 16 o 32 KByte.
Inizialmente (fino alla 2.1) la DVM non
supportava la compilazione Just-In-Time (JIT)
perché si pensava non necessaria poiché per i
calcoli più impegnativi (grafica e codec
audio/video) erano presenti dei coprocessori ed
in ultima istanza si poteva ricorrere alla JNI
(Java Native Interface).
Dalla versione 2.2 di Android la DVM possiede
un Just-In-Time (JIT) compiler.
SEMM2013
Installazione
Nel momento in cui si installa nel sistema una
nuova applicazione Android vengono eseguite le
seguenti operazioni:
●
●
Per sicurezza si effettua la verifica che tutti gli
indici interni ai file dex siano corretti.
Anche se non si utilizzano tecniche JIT il
codice viene ottimizzato ad esempio
spostando i dati dove conviene averli e
ricopiando alcune funzioni che conviene
avere ”inline”.
SEMM2013
VM basata su stack o su registri?
●
●
●
●
La Java VM è stack-based, ovvero tutte le
operazioni agiscono sugli operandi che stanno
sulla cima dello stack.
La Dalvik VM è invece stata progettata registerbased, ovvero le operazioni agiscono su alcuni
registri virtuali.
Le statistiche di Google dicono che in questo
modo si esegue il 30% di istruzioni in meno.
Anche il numero di accessi in memoria si
riduce.
SEMM2013
Sicurezza
●
●
Un'applicazione, per default, non ha il permesso
di eseguire alcuna operazione che può avere
impatto negativo su altre su altre applicazioni,
sul sistema operativo o sull'utente.
Ciò comprende la lettura e la scrittura di dati
privati dell'utente (contatti, e-mail, ...), leggere
o scrivere i file relativi al altre applicazioni,
accedere alla rete, mantenere il dispositivo
attivo, etc.
SEMM2013
Il processo Zygote 1/2
In fase di inizializzazione del sitema viene creato
un processo denominato Zygote.
Esso si occupa di:
●
●
●
Caricare le Core system libraries dex-files
●
Inizializzare la Dalvik VM
Nel momento in cui viene avviata una Activity il
processo Zygote subisce una fork e
successivamente:
Sono caricati i dex files specifici dell'Applicazione
Vengono condivise le Core System Libraries
SEMM2013
Il processo Zygote 2/2
Il processo Zygote rimane in esecuzione in background.
All'avvio di una nuova applicazione, il processo esegue una fork:
●uno dei due processi creati rimane in esecuzione in background
●l'altro inizializza un nuovo esemplare di DVM.
Se durante l'esecuzione di questa applicazione deve essere lanciata una
ulteriore applicazione, il processo in background esegue una secondo
fork.
In ogni momento è quindi disponibile un processo Zygote per
l'inizializzazione di una nuova DVM.
SEMM2013
Conclusioni
Anche se all'apparenza la macchina virtuale usata
da Android può sembrare un clone di quella Java,
ovvero uno stratagemma usato da Google per
non pagare royalties a Sun Microsystems, in
realtà è stato fatto un accurato lavoro di
ottimizzazione per permettere che le applicazioni
Android possano essere eseguite abbastanza
velocemente anche su telefoni con risorse
limitate, in particolare con poca RAM.
SEMM2013
Sistemi Embedded - Android
Lezione n. 5
Installare l'SDK
Introduzione
Per sviluppare una applicazione per Android è
necessario scaricare l'SDK dal sito ufficiale.
SDK sta per Software Development Kit e contiene
una serie di tool ed un emulatore per testare le
applicazioni create direttamente sul proprio PC.
83
Prerequisiti
●
●
●
●
10/2012
Android può essere installato su Windows
(XP,Vista, 7), Linux (Ubuntu dalla 8.04) e Mac
OS X (dalla 10.5.8/x86).
Bisogna avere installato il Java Development
Kit (JDK) versione 6 (non è sufficiente il
runtime-environment JRE)
L'IDE ”fortemente” consigliato è Eclipse (dalla
3.6.2 Helios o successivo) insieme al JDT
plugin
Infine, è necessario installare l'ADT (Android
Development Tools) plugin
84
Download
10/2012
Il sito di riferimento per gli sviluppatori Android è
http://developer.android.com/
Partendo dalla home page bisogna:
●
andare alla sezione ”SDK”,
●
cliccare su ”Download the SDK”,
●
accettare le condizioni di licenza e scaricare il file
ZIP relativo al proprio sistema operativo.
L'ultima versione corrente è:
Android SDK r20 (API Level 16)
85
Installare l'SDK 1/2
●
●
●
In realtà l'SDK non prevede una installazione vera e
propria: è sufficiente scompattare il file ZIP in una
cartella, il cui path sarà utilizzato in Eclipse. Per es.:
●
Windows: C:\apps\android-sdk-windows
●
Linux: /home/username/androidsdk_linux_86
●
Mac OS X: /Users/username/android_sdk_86
Per Windows è disponibile un installer.
A questo punto è possibile già sviluppare,
debuggare, interagire con l'emulatore da riga di
comando.
86
Installare l'SDK 2/2
●
Se si vuole lavorare a riga di comando è necessario
aggiungere alla variabile di ambiente PATH il
percorso completo della sottodirectory ”tools” e
”platform-tools”
87
Installare l'SDK
●
●
●
(MAC OS X) 1/2
Il file in cui indicare il path è ~/.bash_profile
Per verificare se esiste è sufficiente aprire un
Terminale nella home e digitare ls -a
Se esiste editarlo con il comando:
open -a TextEdit .bash_profile
●
Aggiungendo le seguenti righe:
export PATH=$PATH:<sdk>/platform-tools
export PATH=$PATH:<sdk>/tools
88
Installare l'SDK
●
(MAC OS X) 2/2
Altrimenti, se non esiste, nella home digitare:
echo 'export PATH=<sdk>/plaftom-tools:$PATH' >>
~/.bash_profile
echo 'export PATH=<sdk>/tools:$PATH' >>
~/.bash_profile
89
Installare il plugin ADT
Se invece si preferisce lavorare all'interno di un
ambiente integrato di sviluppo è possibile
installare il plugin ADT (Android Development
Tools) all'interno dell'IDE Eclipse.
Per fare ciò all'interno di Eclipse bisogna
selezionare ”Help | Install New Software...” ed
aggiungere il seguente sito:
https://dl-ssl.google.com/android/eclipse/
90
Configurare il plugin
L'unica configurazione richiesta dal plugin ADT
per funzionare correttamente all'interno di
Eclipse consiste nel fornirgli il percorso completo
all'interno del quale è stato scompattato l'SDK.
Per fare ciò in Eclipse bisogna selezionare:
MAC: ”Eclipse > Preferences..”
Altri: ”Window > Preferences... ”
E poi ”Browse...” e selezionare la cartella
dell'SDK utilizzata al passo precedente per la
scompattazione.
91
Aggiornare il plugin
Periodicamente potrebbero essere rilasciati
aggiornamenti del plugin ADT per Eclipse.
Si suggerisce pertanto di controllare di tanto in tanto
selezionando ”Help | Software Updates” e provando ad
aggiornare il plugin di Android.
92
Aggiornare l'SDK
Mediante l'Android SDK Manager (che può essere
richiamato sia dall'ambiente Eclipse, sia da riga di
comando (Android) è possibile seguire gli
aggiornamenti dell'SDK, nonchè installare esempi,
documentazione e le importanti Google API.
Inoltre l'emulatore deve essere lanciato almeno
una volta a riga di comando con l'opzione ”-wipedata” in modo da cancellare i dati relativi alle
esecuzioni precedenti.
93
Test installazione 1/2
Tramite riga di comando digitiamo il comando:
android
Sarà visualizzato l' Android SDK Manager.
Avremmo ottenuto lo stesso risultato utilizzando
Eclipse mendiante la voce di menu:
Window>Android SDK Manager
oppure sulla relativa icona.
Nota: le Google API
94
Test installazione 2/2
Tramite riga di comando digitiamo il comando:
android avd
Sarà visualizzato l' Android Virtual Devices
Manager (AVD Manager).
Avremmo ottenuto lo stesso risultato utilizzando
Eclipse mendiante la voce di menu:
Window>Android AVD Manager
oppure sulla relativa icona.
95
Conclusioni
In questa lezione abbiamo visto come installare,
configurare ed aggiornare il Software
Development Kit (SDK) di Android ed il relativo
plugin per l'IDE Eclipse.
96
Sistemi Embedded - Android
Lezione n. 6:
Strumenti di sviluppo
97
Introduzione
In questa lezione verranno elencati e descritti
brevemente i principali strumenti di sviluppo forniti
con l'SDK di Android, in modo da prendere
dimestichezza con ognuno di essi.
98
Emulatore Android
●
●
L'SDK include l'emulatore di un dispositivo
mobile in grado di girare su un comune PC.
L'emulatore
permette di
testare le
applicazioni
sviluppate senza
disporre del
dispositivo fisico.
99
Caratteristiche dell'emulatore
●
●
L'emulatore emula il comportamento hardware
e software di un tipico smartphone, con la sola
eccezione di non essere in grado di effettuare
vere telefonate.
In compenso le sue capacità di debugging
fanno sì che tramite una console testuale sia
possibile leggere il log del kernel e simulare
l'arrivo di interruzioni (come ad esempio la
ricezione di un SMS).
100
Funzionamento interno
L'emulatore Android è basato su QEMU (un noto
emulatore open-source) e fornisce l'emulazione di:
●
una CPU ARMv5 e la corrispondente MMU (Memory
Managment Unit)
●
un display LCD con 64K colori
●
una o più tastiere
●
un chip audio con input e output
●
l'accesso a partizioni sulla memoria Flash
●
un modem GSM, inclusa una SIM simulata
●
una video-camera, utilizzando la webcam del pc
http://developer.android.com/guide/developing/devices/emulator.html
101
Screen Configuration
Low density
(120), ldpi
Medium density
(160), mdpi
High density
(240), hdpi
480x640
Extra high density
(320), xhdpi
Normal scree WQVGA400
n
(240x400) WQVGA432
(240x432)
HVGA
(320x480)
WVGA800
(480x800) WVGA854
(480x854) 600x1024
640x960
Large screen
WVGA800
(480x800) WVGA854
(480x854)
WVGA800
(480x800) WVGA854
(480x854) 600x1024
Extra
Large screen
1024x600
WXGA
(1280x800)
1024x768
1280x768
1536x1152
1920x1152 1920x1200
2048x1536
2560x1536 2560x1600
Small screen
QVGA
(240x320)
102
Emulator Keyboard Key
Menu (left
softkey)
F2 or Page-up button
Star (right
softkey)
Shift-F2 or Page Down
Back
ESC
Call/dial button
F3
Hangup/end call F4
button
Switch to next layout KEYPAD_9, Ctrl-F12
orientation (for
example, portrait,
landscape)
Toggle cell
networking on/off
F8
Toggle code profiling F9 (only with trace startup option)
Toggle fullscreen
mode
Alt-Enter
KEYPAD_PLUS, Ctrl-5
Toggle trackball
mode
F6
Audio volume
down button
KEYPAD_MINUS, Ctrl-F6
Enter trackball mode Delete
temporarily (while
key is pressed)
Camera button
Ctrl-KEYPAD_5, Ctrl-F3
Switch to
previous layout
orientation (for
example,
portrait,
landscape)
KEYPAD_7, Ctrl-F11
Search
F5
Power button
F7
Audio volume
up button
DPad
left/up/right/down
KEYPAD_4/8/6/2
DPad center click
KEYPAD_5
Onion alpha
increase/decrease
KEYPAD_MULTIPLY(*) /
KEYPAD_DIVIDE(/)
103
Attività 1/2
●
Creare un nuovo AVD (es. Android2.3.3)
●
Avviarlo (da Eclipse e riga di comando)
emulator @Android2.3.3
●
Descrivere le principali caratteristiche
●
Utilizzare le keyboard Key
●
Chiusura
●
Individuare l'immagine e i file di configurazione
dell'AVD creato
104
Attività 2/2
●
Interagire con l'AVD utilizzando ad es.:
●
Chiamata
●
SMS
●
Batteria
●
Tramite DDMS
●
Tramite riga di comando:
telnet localhost 5554
gsm call 12345678
power status full
sms send 12345678 Ciao!
105
L'Android Debug Bridge (o ADB)
●
●
Permette inoltre di accedere a riga di comando
al dispositivo virtuale e reale e di metterlo in
collegamento con un debugger standard.
Permette di installare i file .apk di una
applicazione sull'emulatore o sul dispositivo.
106
Attività 1/2
●
Visualizzare gli AVD o dispositivi reali connessi:
adb devices
●
Aprire una shell direttamente sull'emulatore
adb shell
●
●
adb push nome_file_da_mandare <percorso-inemulatore>/nome_file_destinazione
adb pull <percorso-in-emulatore>/nome_file
nome_file_destinazione
●
adb kill-server
●
adb start-server
107
DDMS
●
●
Il Dalvik Debug Monitor Service (o DDMS)
permette di gestire i processi in esecuzione
sull'emulatore o sul dispositivo reale.
E' possibile killare i processi, selezionare uno
specifico processo da debuggare, generare
informazioni di trace, visualizzare le
informazioni relative allo heap ed ai thread,
catturare screenshot dell'emulatore o del
dispositivo, etc.
108
Hierarchy Viewer
●
●
●
Lo Hierarchy Viewer permette di debuggare e
ottimizzare l'interfaccia utente.
La Layout View fornisce una rappresentazione
visuale della gerarchia di View dell'applicazione.
La Pixel Perfect View fornisce invece una vista
ingrandita del display emulato.
109
Layout View
110
Pixel Perfect View
111
Draw 9-patch 1/3
●
●
E' uno strumento
WYSIWYG che permette
di creare cornici 9-patch.
Si tratta di bitmap
ridimensionabili divise in 9
sezioni: i 4 angoli non
vengono mai scalati, i lati
della cornice vengono
scalati solo in una
dimensione e il solo centro
dell'immagine viene
scalato in entrambe le
dimensioni.
112
Draw 9-patch 2/3
113
Draw 9-patch 2/3
114
AAPT
●
●
L'Android Asset Packaging Tool (o AAPT) è lo
strumento che permette di creare i file .apk
contenenti i binari e le risorse delle applicazioni
Android.
E' lo strumento che viene automaticamente
chiamato da Eclipse per svolgere questo
lavoro, ma può anche essere invocato a riga di
comando.
115
Traceview
●
●
●
Traceview fornisce una rappresentazione
grafica dei log di esecuzione salvati
dall'applicazione.
Il Timeline Panel mostra in quale momento
ogni thread o metodo è stato avviato e fermato.
Il Profile Panel fornisce un riepilogo di cosa è
avvenuto all'interno di un metodo.
116
Timeline Panel
117
Profile Panel
118
mksdcard
●
●
●
mksdcard è uno script che facilita il compito di
creare una immagine di disco che possa essere
usata nell'emulatore.
Simula la presenza di una scheda di memoria
esterna (ad esempio SD-Card).
L'immagine di disco viene creata in formato
FAT32.
119
The Monkey
●
●
Il cosiddetto ”UI/Application Exerciser Monkey”
(letteralmente ”la scimmia che esercita
l'interfaccia grafica e l'applicazione”) è un
programma che gira sull'emulatore o sul
dispositivo reale sequenze pseudo-casuali di
eventi (come i click e vari tocchi dello schermo)
come pure vari tipi di eventi di sistema.
The Monkey è usato per stressare
l'applicazione che si sta sviluppando, in
maniera casuale ma ripetibile.
120
Conclusioni
In questa lezione abbiamo descritto gli strumenti
messi a disposizione dall'SDK che possono
essere particolamente utili per risolvere specifici
problemi.
121
Sistemi Embedded - Android
Lezione n. 7:
Sviluppo di una applicazione
Introduzione
●
●
●
Questa lezione mostra il ciclo di sviluppo
tipico di una applicazione per Android.
Verrà mostrato come creare e compilare
un nuovo progetto, e come eseguirlo
nell'emulatore.
Verrà mostrato il procedimento da usare
con Eclipse o su riga di comando.
123
Creare un progetto Eclipse passo 1
●
●
Per iniziare lo sviluppo di una nuova
applicazione per Android bisogna creare un
progetto e una configurazione di lancio.
Per creare il progetto bisogna ovviamente
disporre di Eclipse e del plugin ADT installato
correttamente.
124
Creare un progetto Eclipse
passo 2
●
●
Il progetto si crea
selezionando
nell'ordine ”File | New
| Project | Android |
Android Project”.
Successivamente
dovranno essere
definiti il project
name, il target,
l'activity name,
application name ed il
package name
125
Creare un progetto Eclipse passo 3
126
Creare un progetto Eclipse passo 4
127
Creare un progetto Eclipse passo 5
128
Creare un Android Virtual Device
●
●
Per poter eseguire la
nostra applicazione è
necessario disporre di
un Android Virtual
Device (AVD)
Per crearne uno tramite
Eclipse andare su
Window | Android Sdk
and AVD Manager,
oppure richiamando il
tool Emulator senza
argomenti da prompt
dei comandi
129
Creare la configurazione di lancio
●
●
Bisogna creare una configurazione di lancio in Eclipse
selezionando il menu ”Run” e poi uno dei quattro tra ”Open
Run Dialog”, ”Open Debug Dialog”, ”Run Configurations”
oppure ”Debug Configurations”.
Dopo avere assegnato un nome alla configurazione
specificare il nome del progetto, l'Activity da lanciare ed
eventuali parametri da passare all'emulatore.
130
Eseguire e debuggare l'applicazione
●
●
●
Adesso è possibile avviare l'applicazione
selezionando ”Run | Run” oppure ”Run | Debug” a
seconda di quello che si intende fare.
Questa azione farà riferimento alla configurazione
di lancio usata più di recente.
I passi che adesso verranno eseguiti saranno
nell'ordine l'avvio dell'emulatore, la compilazione
del progetto (solo in caso di modifiche) e
l'installazione dell'applicazione nell'emulatore.
131
Sviluppo con altri IDE
●
●
●
●
L'ambiente di sviluppo raccomandato per
sviluppare una applicazione Android è Eclipse
con il plugin ADT installato, ma è possibile
utilizzare altri metodi.
A partire dalla versione 9 l'IDE IntelliJ IDEA di
JetBrains integra un supporto all'Android SDK.
E' possibile utilizzare l'IDE Eclipse senza avere
installato il plugin ADT.
In tutti i casi i tool contenuti nell'SDK forniscono
gli strumenti per configurare, compilare e
debuggare una applicazione.
132
Creare un progetto da riga di comando
●
Per creare un nuovo progetto da riga di
comando si utilizza sempre il tool android:
android create project
-t <target_ID>
-n <your_project_name>
-p path/to/your/project
-a <your_activity_name>
-k <your_package_namespace>
●
android create project
-t 8
-n prova
-p c:\prova
-a ActivityDemo
-k it.corso.activitydemo
Assicurarsi di avere inserito le directory
platform-tools/ e tools/ tra le directory della
variabile d'ambiente PATH
133
File ottenuti 1/3
L'esecuzione del precedente comando
produce in output i seguenti file:
●
●
●
●
AndroidManifest.xml è il file di manifesto
contenente le informazioni relative al progetto
build.xml è un file Ant che può essere usato
per compilare l'applicazione a riga di comando
src/it/corso/ActivityDemo.java è il file
sorgente che conterrà l'activity specificata.
proguard.cfg è utilizzato dal tool proguard che
offusca ed ottimizza il codice producendo un
.apk di dimensioni ridotte.
134
File ottenuti 2/3
●
●
default.properties
descrive la
configurazione del
progetto compreso il
build target. Non
dovrebbe essere
editato manualmente.
build.properties può
essere editato per
sovrascrivere le
impostazioni di build
usate da Ant. Se si
usa Eclipse questo file
viene ignorato.
135
File ottenuti 3/3
●
●
●
●
gen/ contiene i file .Java generati dall'ADT
come per es. R.java.
res/ contiene le risorse dell'applicazione
(immagini, stringhe, layout)
assets/ inizialmente vuota contiene altri file di
risorse come texture o dati cui e non sono
associati alle costanti della classe R.
libs/ contiene le library utilizzate
dall'applicazione
136
Directory ottenute
Vengono inoltre create le seguenti cartelle:
●
src/ conterrà i sorgenti
●
res/ per le risorse esterne
●
bin/ contiene il file .apk e le altre risorse compilate
●
jni/ contiene il codice nativo sviluppato mediante
l'Android NDK
In realtà tutte le directory anche in seguito possono
essere spostate dove si vuole, mentre non è
possibile spostare l'SDK perché gli script di build
fanno riferimento ad esso.
137
Settare l'ambiente per la
compilazione
●
●
Per compilare il progetto a riga di comando è
necessario avere installato Apache Ant 1.8 o
successivo.
Bisogna inoltre settare la variabile d'ambiente
JAVA_HOME per puntare correttamente al
percorso in cui è installato il JDK; sotto
Windows tale percorso NON può contenere
spazi, quindi ad esempio non è possibile
installare il JDK nella directory predefinita
”Program Files”:
set JAVA_HOME=c:\Programmi\Java\
138
Compilare a riga di comando
●
●
Dopo avere settato la variabile d'ambiente
JAVA_HOME è sufficiente spostarsi nella
directory che contiene il file build.xml ed
eseguire semplicemente ”ant”.
Ovviamente ogni volta che si cambia un file
sorgente o una risorsa bisogna ricompilare tutto
rieseguendo il comando ”ant”.
139
Avviare l'emulatore a riga di
comando
●
●
Per eseguire la propria applicazione bisogna
innanzitutto caricarla all'interno del file-system del
sistema emulato.
Per prima cosa bisogna avviare l'emulatore con il
comando:
emulator @avd_name
●
Per conoscere gli AVD disponibili (prec. creati):
android list
●
Nell'interfaccia grafica dell'emulatore la vecchia
versione della propria applicazione non deve essere in
primo piano, quindi conviene spostarsi alla pagina
principale premendo il pulsante ”Home”.
140
Attività 1/2
●
●
●
●
Per installare la propria applicazione da riga di
comando si può utilizzare il comando ADB (con
un AVD avviato).
La sintassi da usare è adb install
bin/<nome_applicazione>.apk
Questo comando ricopia il file APK all'interno
della directory /data/app dell'emulatore.
Accedendo all'emulatore la nostra applicazione
apparirà tra quelle installate.
141
Attività 2/2
Rimuovere l'applicazione installata
●
Tramite l'emulatore
●
Utilizzando l'ADB
adb uninstall it.dominio.nomepackage
Es:
adb uninstall it.corso.helloandroid
●
Verificare l'avvenuta rimozione dell'app
142
Conclusioni
In questa lezione abbiamo visto come creare un
nuovo progetto Eclipse e come eseguire la nostra
applicazione all'interno dell'emulatore.
Abbiamo inoltre visto come sia possibile effettuare
le stesse operazioni anche senza Eclipse,
utilizzando solo gli strumenti a riga di comando
forniti con l'SDK di Android.
143
Sistemi Embedded - Android
Lezione n. 8:
Anatomia di una applicazione
Elementi di base
Gli elementi di base per costruire una applicazione
Android sono cinque:
●
Activity
●
Intent
●
Broadcast Receiver
●
Service
●
Content Provider
145
Activity (1/3)
●
●
●
●
Le Activity sono l'elemento di base più comune.
Rappresentano blocchi logici dell'applicazione ed
interagiscono con l'utente mediante i dispositivi di
input dello smartphone.
Serve una Activity per ogni schermata
dell'applicazione (es. una per comporre un
messaggio, una per consultare la rubrica e una
per le configurazioni).
Vengono derivate dalla classe base
android.app.Activity.
146
Activity (2/3)
●
●
●
●
La propria Activity derivata mostrerà una
interfaccia utente composta da View e
risponderà ad eventi.
Spostarsi da una schermata all'altra fa avviare
una nuova Activity.
In certi casi l'Activity chiamata restituirà un
valore all'Activity chiamante (ad esempio una
schermata che permette di selezionare una foto
restituirà al chiamate la foto scelta).
Quando si apre una nuova schermata, quella
precedente è messa in pausa e inserita in una
pila (activity stack).
147
Activity (3/3)
●
●
●
L'utente può quindi navigare avanti e indietro
tra le schermate aperte nell'activity stack.
Per alcune schermate può essere inappropriato
rimanere nell'activity stack, e in questo caso è
possibile rimuoverle.
Android mantiene un activity stack per ogni
applicazione lanciata dalla schermata Home.
148
Activity - Fragment
●
●
Con Android 3.0 sono stati introdotti i Fragment.
Un Fragment costituisce una porzione di UI di una
data Activity con le seguenti proprietà:
●
E' caratterizzata da un proprio ciclo di vita
●
Possiede un proprio input
●
●
Può essere aggiunto e rimosso mentre l'Activity è in
esecuzione
Per es., una Activity potrebbe includere molti
Fragment quando il display è abbastanza ampio,
oppure solo alcuni in caso contrario.
149
Intent 1/4
●
●
●
●
L'Intent rappresenta un messaggio in grado di
attivare i tre componenti-base di una
applicazione: Activity, Service e Broadcast
Receiver
Un Intent descrive cosa una applicazione vuole
che venga fatto.
La struttura dati dell'Intent si compone
dell'azione da effettuare e dei dati su cui agire.
Valori tipici per l'azione sono MAIN (la
schermata principale dell'applicazione), VIEW,
PICK, EDIT etc.
150
Intent 2/4
Un Intent può essere Esplicito o Implicito:
●
●
Esplicito: all'interno del costruttore dell'Intent
specifichiamo la classe da eseguire (tipicamente
una Activity).
Nell'esempio seguente è istanziato un Intent in
cui è dichiarata una Activity da eseguire.
Intent intent = new Intent(this, SubActivity.class);
startActivity(intent);
151
Intent 3/4
●
●
Implicito: rappresenta l'essenza della filosofia
Android. Un Intent implicito dichiarata l'azione da
eseguire pur senza sapere chi la eseguirà.
Nel seguente esempio è dichiarato un Intent
mediante cui avviare una Activity che
visualizzerà il sito definito nell'URI
Uri uri = Uri.parse("http://www.google.com");
Intent it = new Intent(Intent.ACTION_VIEW,uri);
startActivity(it);
152
Intent 4/4
●
●
In generale, potrebbe essere necessario
richiedere specifici ”permission” per eseguire un
particolare Intent
Tali permessi devono essere dichiarati nel
manifest.xml, ad esempio:
<uses-permission
android:name="android.permission.INTERNET" />
153
IntentFilter 1/2
●
●
●
●
Una classe correlata si chiama IntentFilter.
Una Activity che è in grado di mostrare le
informazioni di contatto per una persona
pubblicherà un IntentFilter nel quale dirà che sa
come gestire l'azione VIEW quando essa è
applicata a dati che rappresentano una
persona.
Le Activity pubblicano i loro IntentFilter nel file
AndroidManifest.xml.
La navigazione da una schermata all'altra viene
effettuata risolvendo gli Intent.
154
IntentFilter
Un IntentFilter sempre presente nella nostra
applicazione è il seguente:
<activity android:name=".IntentSample"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
●
●
La action dichiara che si tratta di un entry point,
mentre la category indica che questo entry point
può essere listato nell'Application Launcher
Ovvero, la nostra Activity si rende disponibile nella
home per essere eseguita mediante click/tap
sull'icona relativa
155
Intent - Navigazione
Per navigare avanti una Activity chiama
startActivity(myIntent);
Il sistema guarda quindi gli IntentFilter per tutte le
applicazioni installate e sceglie l'Activity il cui
IntentFilter è più appropriato per myIntent.
La nuova Activity è informata dell'Intent, e viene
quindi lanciata.
156
Intent - Esecuzione a run-time
Il fatto di risolvere gli Intent al tempo di esecuzione
solo quando startActivity() viene chiamata
comporta almeno due benefici principali:
●
●
Le Activity possono riutilizzare funzionalità di
altri componenti semplicemente facendo una
richiesta sotto forma di un Intent.
Le Activity possono essere sostituite in ogni
momento da una nuova Activity con un
IntentFilter equivalente.
Rif:
http://developer.android.com/reference/android/
content/Intent.html
157
BroadcastReceiver 1/2
●
●
●
Il secondo elemento di base di una
applicazione è la classe BroadcastReceiver
definita all'interno del package android.content.
Viene utilizzato quando si vuole che parte del
codice della propria applicazione venga
eseguito in risposta ad un evento esterno (es. il
telefono squilla, o una connessione dati diventa
disponibile, oppure quando è mezzanotte).
Affinché un BroadcastReceiver venga chiamato
non è necessario che la relativa applicazione
sia in esecuzione.
158
BroadcastReceiver 2/2
●
●
●
I BroadcastReceiver non hanno interfaccia
grafica, ma possono usare il
NotificationManager per avvisare l'utente che è
successo qualcosa di interessante.
Anche i BroadcastReceiver come gli IntentFilter
sono registrati nel file AndroidManifest.xml, ma
possono essere anche registrati dal sorgente
usando la chiamata Context.registerReceiver().
Le applicazioni possono lanciare i broadcast
alle altre con Context.sendBroadcast().
159
Service
●
●
Un altro elemento di base delle applicazioni
Android è il Service, ovvero del codice senza
interfaccia grafica e sono definiti all'interno del
package android.app.
Un buon esempio è la riproduzione di un brano
musicale: poiché si vuole che la riproduzione
continui anche dopo che l'utente ha cambiato
schermata, non la si può lasciare eseguire ad
una Activity ma bisogna chiamare
Context.startService() per eseguirla in
background.
160
Cosa non è un service
●
●
Un Service non è un processo separato: in altre
parole l'applicazione e il suo servizio sono
eseguiti all'interno dello stesso processo (se
non altrimenti specificato)
Non è un thread: non è uno strumento
mediante cui fare eseguire delle attività al di
fuori del thread principale
161
Cosa è un service
●
●
Un Service è uno strumento mediante cui
l'applicazione vuol comunicare al sistema che
una data operazione deve essere eseguita in
background anche quando l'utente non sta
interagendo direttamente con essa.
Uno strumento mediante il quale l'applicazione
mette a disposizione di altre applicazioni alcune
delle proprie funzionalità. Ciò può essere
realizzato invocando una Context.bindService()
mediante la quale viene stabilita una
connessione tra l'applicazione richiedente ed il
servizio richiesto.
162
Content Provider
●
●
●
L'ultimo elemento di base è il Content Provider,
definito all'interno della classe Android.Content
Solitamente le applicazioni memorizzano i loro
dati all'interno del file-system oppure in un
database SQLite, ma se i dati di una
applicazione devono essere condivisi con le
altre bisogna usare la classe ContentProvider.
Un ContentProvider è una classe che
implementa un insieme standard di metodi per
permettere alle altre applicazioni di salvare e
recuperare dati.
163
Conclusioni
In questa lezione abbiamo visto brevemente le
quattro classi alla base di ogni applicazione
Android: Activity, Intent, BroadcastReceiver,
Service e ContentProvider.
164
Sistemi Embedded - Android
Lezione n. 9:
Ciclo di vita di Activity, Service
e Processi
Activity 1/3
●
●
Pur essendo possibile
avviare più applicazioni
contemporaneamente
soltanto una può occupare
il display, mentre le altre
saranno ”nascoste” in
background
Questo è il motivo per cui,
il concetto di chiusura è
secondario e normalmente
non troveremo il punsante
”Esci”
166
Activity 2/3
●
●
●
●
●
OnCreate(Bundle): e' invocato quando l'activity viene
avviata per la prima volta. Il Bundle savedInstanceState
serve per riportare l'Activity nello stesso stato in cui si
trovava la precedente istanza dell'Activity terminata.
OnStart(): è invocato quando l'activity sta per essere
visualizzata
onResume(): è invocato non appena l'activity inizia ad
"interagire" con l'utente
onPause(): è invocato non appena l'activity sta per essere
”ibernata” (per es. e' stata avviata un'altra activity)
onStop(): è invocato nel momento in cui l'activity non e'
piu' visibile all'utente.
167
Activity 3/3
●
●
●
●
onRestart(): è invocato quando l'Activity sta per essere
riavviata dopo essere stata precedentemente arrestata
onDestroy(): è invocata poco prima che l'Activity sia
distrutta
onSaveInstanceState(Bundle): è invocata per salvare
lo stato dell'Activity
onRestoreInstanceState(Bundle): è invocata solo se
in precedenza è stato salvato uno stato
168
Ciclo di vita di un Service
●
●
Quando viene invocato il metodo
startService() il sistema verifica se
tale servizio è in escuzione
altrimenti esegue onCreate()
Successivamente è invocato il
metodo onStartCommand() e il
servizio è finalmente nello stato di
esecuzione dove rimane fino a
quando non sarà richiamato
stopService() oppure stopSelf().
169
Service 1/2
●
●
onCreate(): a differenza delle Activity non
presenta alcun parametro. Creato il servizio
viene invocato il metodo onStartCommand().
Viene invocato una sola volta.
onStartCommand(): invocato questo metodo il
servizio resterà in esecuzione e rimarrà in questo
stato fino a quando non sarà invocato
stopService() da parte dell'Activity che lo ha
generato, oppure stopSelf() da parte del servizio
stesso. Può essere invocato più volte in seguito
all'esecuzione di onStartService() da parte
dell'Activity.
170
Service 2/2
●
onDestroy(): l'invocazione di stopService() da
parte dell'Activity produrrà la chiamata di questo
metodo del Servizio. In seguito a questa
chiamata il servizio sarà eliminato
171
Applicazioni e Processi
●
●
●
Per ogni applicazione che viene eseguita,
Android avvia un nuovo processo Linux
Di default, tutti i componenti di una data
applicazione (per es. Activity + Service) sono
eseguiti all'interno dello stesso processo
Se al momento di avviare una applicazione esiste
già un processo assegnato ad essa perchè un
suo componente è stato eseguito in precedenza,
allora tale applicazione sarà eseguita all'interno
di questo processo
172
Applicazioni e Processi
●
●
●
Nel caso in cui la momoria a disposizione per
eseguire una applicazione in foreground (visibile
all'utente) ovvero per eseguire un importante
processo non sia disponibile, allora il sistema può
decidere di eliminare uno o più processi in
background secondo una logica ben definita
Ad ogni processo viene assegnata una sorta di
importanza gerarchica in base ai suoi
componenti in esecuzione ed al loro stato
Ovviamente i processi di minore importanza
saranno i primi ad essere eliminati per liberare
memoria
173
Applicazioni e Processi
Sono state definite 5 tipologie di processi ordinate
per importanza decrescente:
●
Foreground Process
●
Visible Process
●
Service Process
●
Background Process
●
Empty Process
174
Foreground Process
I processi Foreground sono quelli che eseguono
componenti di interazione con l'utente:
●
Activity in cima allo Stack
●
Azioni di un BroadCastReceiver (OnReceive())
●
Metodi di callback nella gestione di un servizio
come Start(), Create() o Destroy()
Normalmente il numero di questo tipo di processi è
limitato. Android potrà decidere di eliminarne uno
come ultima chance per risolvere il problema di
memoria
175
Visible Process
Sono processi che pur non essendo direttamente
visibili all'utente (non possiedono componenti in
Foreground, si trovano in uno stato in cui possono
comunque avere effetto su quello che l'utente vede
visualizzato.
●
●
Activity non in Foreground che esegue
OnPause()
Service connesso ad un'Activity in Foreground.
176
Service Process
●
●
●
Sono processi che eseguono Service
Pur non interagendo direttamente con l'utente,
Android li ritiene più importanti delle Activity in
Background
L'esempio classico è la riproduzione di un file
audio: pur non interagendo direttamente con
l'utente, questo accetterà malvolentieri
l'interruzione dell'ascolto del brano. Pertanto
Android proverà ad eliminare uno o più processi
meno importanti prima di eliminare un Service
Process
177
Background Process
●
●
●
●
Sono processi che si occupano di eseguire
Activity non più in Foreground per i quali è stato
invocato il metodo OnStop()
Il loro numero è in genere superiore a quello
delle altre categorie
L'eliminazione all'interno di questa categoria
tiene in considerazione il criterio di Least Recent
Used (LRU)
Per questi processi è comunque definito un
meccanismo di salvataggio e ripristino
178
Empty Process
●
Sono i processi candidati per l'eliminazione.
●
Non eseguono alcun componente
●
●
Il motivo per cui non vengono eliminati nel
momento in cui sono svuotati dai componenti che
eseguivano è legato a strategie di caching
Gli empty Process più vecchi saranno
velocemente eliminati, mentre per quelli più
recenti è più probabile che l'utente richiami un
suo componente precedentemente visualizzato
179
Sistemi Embedded - Android
Lezione n. 10:
Hello, Android!
Introduzione
In questa lezione vedremo come applicare i
concetti acquisiti nella lezione precedente e
creeremo la nostra prima applicazione per
Android.
Come tradizione la prima applicazione sviluppata
in un nuovo linguaggio si chiama ”Hello World”
(nel nostro caso ”Hello Android”) e si limita a
visualizzare sullo schermo un messaggio di
saluto.
Creare il progetto
●
Per creare il progetto
Eclipse bisogna
selezionare ”File |
New | Project |
Android Project”:
Dettagli del progetto
Nome progetto e Activity
●
●
Il nome del progetto e il nome dell'Activity possono
coincidere o meno: nell'esempio il progetto è
”HelloAndroid” e l'activity è
”HelloAndroidActivity”.
La differenza è che il progetto dà il nome alla
directory che lo conterrà, mentre il nome
dell'Activity è il nome della classe che deriveremo
dalla classe Activity di Android e che sarà la classe
principale dell'applicazione.
Nome del package
Bisogna specificare il namespace sotto il quale si
vuole che risieda il nostro codice sorgente,
seguendo le stesse regole del linguaggio Java.
Poiché è importante che nel sistema il nome del
package sia unico rispetto a tutti quelli installati
nel sistema, si usa un nome di package in stile
”nome di dominio”. Nell'esempio è stato utilizzato
”it.corso”.
Nome dell'applicazione
L'ultimo dettaglio da specificare al momento della
creazione del progetto è l'Application Name:
questo è il nome dell'applicazione che apparirà sia
come descrizione nell'elenco di applicazioni
installate che sulla barra del titolo quando la
nostra applicazione sarà in esecuzione, quindi è
importante che si tratti di un nome facilmente
comprensibile: nel nostro caso ”HelloAndroid”.
Può contenere spazi e punteggiatura.
AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="it.corso.helloandroid"
android:versionCode="1"
android:versionName="1.0">
<uses-sdk android:minSdkVersion="8" />
<application android:icon="@drawable/icon" android:label="@string/app_name">
<activity android:name=".HelloAndroidActivity"
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>
Codice autogenerato
Dopo avere cliccato su ”Finish” il file
HelloAndroidActivity.Java conterrà il seguente codice:
package it.corso.helloandroid;
import android.app.Activity;
import android.os.Bundle;
public class HelloAndroidActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
Codice modificato
package it.corso.helloandroid;
import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
public class HelloAndroidActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
TextView tv = new TextView(this);
tv.setText("Hello, Android!");
setContentView(tv);
}
}
View e TextView
●
●
●
In Android le interfacce utente sono composte
da gerarchie di classi dette View.
Una View è semplicemente un oggetto che può
essere disegnato, come un radio button, una
animazione o (come nel nostro caso) una
etichetta di testo.
Il nome della sottoclasse della classe View che
permette di gestire il testo è semplicemente
TextView.
Creazione della TextView
Per creare una TextView si procede come si fa di
solito in Java invocando il costruttore:
TextView tv = new TextView(this);
L'argomento passato al costruttore deve essere
una istanza del Context di Android, dove il
Context è semplicemente un handle che ci
permette di accedere al sistema (ad esempio per
risolvere risorse, ottenere l'accesso a database e
preferenze e così via).
Metodi di TextView
Poiché la classe HelloAndroid è derivata da
Activity che a sua volta è derivata da Context,
allora al costruttore di TextView possiamo
passare ”this” ovvero la nostra istanza di
HelloAndroid.
Possiamo poi invocare un metodo di TextView per
dirgli quale deve essere il testo da visualizzare:
tv.setText("Hello, Android");
Collegamento al display
Dopo avere creato la TextView e averle detto
quale testo mostrare, l'ultimo passo consiste nel
collegare questa TextView con lo schermo:
setContentView(tv);
Questo metodo di Activity indica al sistema quale
View deve essere associata all'interfaccia grafica
dell'Activity stessa (in questo caso una TextView).
Se non viene mai invocato l'Activity mostrerà solo
uno schermo vuoto.
Eseguire Hello Android
●
Per eseguire l'applicazione a seconda della
versione di Eclipse bisogna selezionare ”Run |
Open Run Dialog” oppure ”Run | Run
Configurations”:
Personalizzare la configurazione
●
●
●
●
●
Selezionare dal menu ”Android Application |
New_configuration”.
Assegnare un nome significativo alla nuova
configurazione, per esempio ”Hello, Android”.
Selezionare il progetto ”HelloAndroid”.
Selezionare l'Activity principale del progetto,
ovvero ”com.android.hello.HelloAndroid”.
Il modulo compilato sarà:
Configurazione di lancio
Esecuzione
●
●
Infine premendo il pulsante ”Run” si otterrà:
Durante l'avvio, la finestra console dell'IDE ci
comunica passo passo le operazioni in corso:
Commenti
●
●
●
Come si vede nell'immagine precedente, la
scritta ”Hello, Android” viene mostrata due
volte.
La scritta più in alto è il nome dell'applicazione
mostrato sulla barra del titolo; è la stringa che
abbiamo scelto come Application Name quando
abbiamo creato il progetto.
Invece la seconda scritta è il testo che abbiamo
associato alla TextView.
Conclusioni
In questa lezione abbiamo visto come creare la
nostra prima applicazione.
Abbiamo messo in pratica quanto appreso alla
lezione precedente riguardo allo sviluppo e
all'esecuzione di una nuova applicazione per
Android.
Abbiamo inoltre iniziato a prendere dimestichezza
con le classi Context, Activity, View e TextView.
Sistemi Embedded - Android
Lezione n. 11:
Elenco dei package
Introduzione
In questa lezione vedremo l'elenco completo dei
package Android che raggruppano le classi che è
possibile utilizzare per sviluppare una
applicazione utilizzando il linguaggio di
programmazione Java.
android
●
●
●
Il package android di livello più alto contiene
due classi relative alle risorse usate dalle
applicazioni.
Contiene la classe R relativa alle risorse.
Contiene inoltre la classe Manifest relativa al
file di manifesto dell'applicazione.
android.app
●
●
●
●
Il package android.app contiene molte classi
usate per incapsulare il modello di applicazione
di Android.
Contiene ad esempio la classe Activity, usata
più volte durante questo corso.
Contiene inoltre la classe Dialog usata per le
finestre di dialogo.
Contiene anche la classe Service usata per i
servizi eseguiti in background.
android.content
●
●
●
●
Il package android.content contiene le classi
usate per accedere e pubblicare dati sul
dispositivo.
Contiene la classe Intent che è la descrizione
astratta di una operazione da compiere.
Contiene inoltre la classe di base
BroadcastReceiver dalla quale si derivano le
classi in grado di ricevere gli Intent.
Contiene l'interfaccia Context per accedere le
informazioni globali dell'applicazione.
android.database
●
●
●
Il package android.database contiene le classi
usate per esplorare i dati restituiti da un
ContentProvider.
Il sottopackage android.database.sqlite
contiene le classi che una applicazione può
utilizzare per gestire il proprio database SQLite.
Contiene ad esempio le classi SQLiteDatabase,
SQLiteOpenHelper e SQLiteQuery.
android.graphics
●
●
●
Il package android.graphics fornisce strumenti
per la grafica di basso livello usati per
disegnare lo schermo direttamente.
Contiene ad esempio le classi Bitmap, Canvas,
Color, Matrix, NinePatch, Paint, Picture, Point,
Rect e Region.
Il sottopackage android.graphics.drawable
fornisce la classe Drawable che contiene i
generici metodi usati per disegnare un oggetto.
android.hardware
●
●
●
Il package android.hardware fornisce il
supporto per l'hardware non necessariamente
presente su tutti i dispositivi Android.
Fornisce ad esempio la classe Camera usata
per interagire con la fotocamera (opzionale sui
dispositivi Android).
Fornisce anche la classe SensorManager con
la quale è possibile interagire coi sensori
(accelerometro, giroscopio, etc.), anch'essi
opzionali.
android.location
●
●
●
Il package android.location fornisce le classi
che permettono di gestire i servizi basati sulla
posizione.
Fornisce ad esempio la classe Location che
memorizza la posizione geografica in un certo
momento.
Fornisce anche la classe Address, ovvero una
stringa che rappresenta un indirizzo.
android.media
●
●
●
●
Il package android.media fornisce le classi che
permettono di gestire vari formati audio e video.
Fornisce la classe MediaPlayer usata per
riprodurre un file multimediale.
Fornisce la classe MediaRecorder usata per
registrare audio e video dal proprio dispositivo.
La classe Ringtone permette di interagire con le
suonerie presenti sul dispositivo.
android.net
●
●
●
●
●
Il package android.net permette di interagire
con la rete in aggiunta alle normali API java.net.
Fornisce ad esempio la classe DhcpInfo per
leggere i risultati di una richiesta DHCP.
La classe NeworkInfo descrive lo stato delle
interfacce di rete.
Il sotto-package android.net.http fornisce le
classi per gestire i certificati SSL.
Il sotto-package android.net.wifi fornisce le
classi per gestire le funzioni Wi-Fi.
android.opengl
●
●
●
Il package android.opengl fornisce le classi per
gestire la grafica OpenGL.
La classe GLU contiene le ”GL Utilities”.
La classe Matrix permette di gestire le matrici
4x4 usate da OpenGL.
android.os
●
●
●
●
Il package android.os fornisce i servizi di base
di un sistema operativo, come il message
passing e la Inter-Process Communication.
Fornisce le classi BatteryManager e
PowerManager per gestire il consumo.
Fornisce la classe Handler in grado di gestire i
messaggi ricevuti.
Fornisce la classe Message che definisce il
messaggio che può essere mandato a un
Handler.
android.preference
●
●
●
Il package android.preference contiene le classi
che gestiscono le preferenze di una
applicazione e ne implementano l'interfaccia
grafica.
Fornisce infatti la classe di base Preference.
Fornisce poi le varie classi
CheckboxPreference, DialogPreference,
EditTextPreference, ListPreference e
RingtonePreference.
android.provider 1/2
●
●
●
Il package android.provider fornisce le classi di
utilità usate per accedere ai Content Provider
forniti da Android.
E' l'unico strumento a disposizione delle
applicazione per condividere dati
Non esiste un'area comune all'interno della
quale i package possono leggere e/o scrivere i
dati
android.provider 2/2
●
●
●
Fornisce il Contacts provider che implementa la
rubrica.
Fornisce il MediaStore provider che contiene i
meta-dati di tutti i file multimediali.
A partire dalla versione 4.0 (API 14) è fornisce
anche il Calendar provider
android.sax
●
●
●
Il package android.sax fornisce un framework
che permette di scrivere gestori SAX robusti ed
efficienti.
Fornisce ad esempio la classe Element che
descrive un singolo elemento XML.
Fornisce la classe RootElement che descrive
l'elemento XML radice.
android.telephony
●
●
Il package android.telephony fornisce le API per
monitorare le informazioni di base del telefono,
come il tipo di rete e lo stato della connessione,
più alcune utilità usate per manipolare stringhe
contenenti numeri di telefono.
Il sottopackage android.telephony.gsm fornisce
le API per utilizzare caratteristiche specifiche
del servizio GSM, come i messaggi SMS.
android.test
●
●
Il package android.test è un framework per
scrivere test case per Android.
Altre classi utili per i test sono contenute nei
sotto-package android.test.mock e
android.test.suitebuilder.
android.text
●
●
●
●
Il package android.text contiene classi usate
per la visualizzazione del testo sullo schermo.
Fornisce la classe AutoText che accede un
dizionario di frequenti errori di digitazione.
Fornisce la classe Html che processa stringhe
HTML e le trasforma in testo visualizzabile sullo
schermo con lo stile corretto.
Include anche diversi sotto-package (method,
style e util).
android.util
●
●
●
Il package android.util fornisce diversi metodi di
utilità, ad esempio metodi di conversione di
stringhe e numeri.
Fornisce la classe TimeUtils che permette di
manipolare data e ora.
Fornisce la classe Xml che contiene metodi di
utilità per gestire file XML.
android.view
●
●
●
Il package android.view fornisce classi che
espongono interfacce utente di base per
disegnare sullo schermo e interagire con
l'utente.
Fornisce ad esempio le classi Menu, SubMenu
e MenuItem usate per gestire i menu.
Il sotto-package android.view.animation
contiene classi usate per gestire semplici
animazioni che possono essere poi applicate a
View, superfici o altri oggetti.
android.webkit
●
●
●
●
Il package android.webkit fornisce gli strumenti
per navigare in rete con un browser.
Fornisce ad esempio la classe URLUtil che
fornisce metodi di utilità per gestire gli URL.
Fornisce la classe Plugin per la gestione dei
plugin del browser.
Fornisce la classe WebView che è un oggetto
View incorporabile nella propria applicazione e
capace di mostrare pagine web.
android.widget
●
●
Il package android.widget contiene molti
elementi grafici che possono essere mostrati
sullo schermo dell'applicazione.
Fornisce ad esempio le classi Button,
Checkbox, EditText, RadioButton, Scroller,
AnalogClock e DigitalClock.
Altri package di Java
●
●
Come visto in precedenza, in Android sono
anche supportati molti package appartenenti
alla API di Java: java.awt.font, java.io,
java.lang, java.math, java.net, java.nio,
java.security, java.sql, java.text e java.util.
Sono anche supportati alcuni package estesi di
Java: javax.crypto,
javax.microedition.khronos.egl,
javax.microedition.khronos.opengles, javax.net,
javax.security, javax.sql e javax.xml.
Ulteriori package
●
●
Android supporta inoltre ulteriori package
disponibili per Java ma esterni alla piattaforma
di Sun Microsystems.
Ad esempio org.apache.http, org.json,
org.w3c.dom, org.xml.sax, junit.framework e
junit.runner.
Conclusioni
In questa lezione abbiamo elencato tutti i package
che raggruppano le classi sviluppate
appositamente per la piattaforma Android.
Abbiamo inoltre visto brevemente altri package
open-source che sono stati integrati nel progetto,
provenienti principalmente da Java e dal progetto
Apache.
Sistemi Embedded - Android
Lezione n. 12:
Implementare una interfaccia
utente
Introduzione
In questa lezione vedremo come implementare
una interfaccia utente sullo schermo di Android.
Vedremo gli elementi di base visualizzabili sullo
schermo ed i layout che permettono di disporre i
vari elementi dell'interfaccia grafica.
228
Gerarchia di elementi dello schermo
●
●
●
Come visto più volte durante questo corso
l'elemento di base di una applicazione sono gli
oggetti della classe android.app.Activity.
Una Activity può fare molte cose, ma di per sé
non ha associata una schermata.
Per assegnare ad una activity una interfaccia
grafica si lavora con oggetti del tipo View e
Viewgroup.
229
android.view.View
●
●
●
La classe View è una struttura dati le cui
proprietà memorizzano il layout e il contenuto di
una specifica area rettangolare sullo schermo.
L'oggetto View gestisce le dimensioni, il layout,
il disegno, il focus, lo scorrimento, i tasti e i
tocchi per lo schermo.
La classe View serve come classe di base per
diversi widget già implementati (Text, EditText,
InputMethod, MovementMethod, Button,
RadioButton, Checkbox e ScrollView).
230
android.view.ViewGroup
●
●
●
Come il nome stesso suggerisce, un
ViewGroup è un oggetto il cui compito è quello
di contenere un insieme di altri View e
ViewGroup.
In tal modo schermate complesse possono
essere gestite come se fossero una unica
entità.
La classe ViewGroup serve come classe di
base per diversi tipi comuni di layout già
implementati.
231
GUI strutturata ad albero
●
●
L'interfaccia grafica di
una Activity è
costituita da un albero
di View e ViewGroup.
Per collegare l'albero
allo schermo, l'Activity
invoca la propria
setContentView()
passando come
argomento il nodo
radice.
232
Disegno dell'albero
●
●
●
Una volta che Android ha il riferimento
all'oggetto del nodo radice può lavorare
direttamente con esso per invalidare, misurare
e disegnare l'albero.
Quando l'Activity diventa attiva e riceve il focus,
il sistema lo notifica all'Activity che richiede
quindi al nodo radice di misurare e disegnare
l'albero.
Il nodo radice richiede quindi ad ognuno dei
nodi figli di disegnare se stessi, e così via.
233
Disegno dei figli
●
●
Ogni ViewGroup ha la responsabilità di
misurare lo spazio disponibile, disporre i suoi
figli e invocare il metodo Draw() su ognuno dei
figli per fare in modo che si disegnino.
Il figlio può quindi richiedere una dimensione e
una posizione nel genitore, ma la decisione
finale su dove e quanto grande possa essere il
figlio spetta all'oggetto genitore.
234
ViewGroup.LayoutParams
●
●
Ogni classe
ViewGroup usa una
classe innestata che
estende
LayoutParams.
Questa sottoclasse
contiene le proprietà
che definiscono
dimensione e
posizione dei figli.
235
Dimensioni
●
●
Tutti i ViewGroup includono larghezza e
altezza; molti includono anche margini e bordi.
A volte potrebbe essere necessario impostare
larghezza e altezza a un valore fisso, mentre
nella maggior parte dei casi si potrebbe voler
richiedere a un ViewGroup di assumere le
dimensioni degli oggetti in essi contenuti
oppure la dimensione massima possibile.
236
Tipi di layout comuni
Alcuni tipi di layout molto comuni sono:
●
FrameLayout
●
LinearLayout
●
TableLayout
●
RelativeLayout
●
GridLayout
237
FrameLayout
●
●
●
●
FrameLayout è l'oggetto di layout più semplice.
E' uno spazio vuoto riservato sullo schermo che
può poi essere riempito con un singolo oggetto.
Tutti gli oggetti figli vengono allineati all'angolo
in alto a sinistra.
I figli aggiunti successivamente andranno quindi
a coprire (totalmente o parzialmente) i figli
aggiunti in precedenza.
238
LinearLayout
●
●
Un LinearLayout allinea
tutti i suoi figli in una
direzione, in orizzontale o
verticale, a seconda di
quale proprietà viene
settata.
Si possono definire gravità
e peso in modo che un
oggetto (es. Comments) si
espanda.
239
TableLayout
●
●
Il TableLayout
dispone i figli in righe
e colonne.
E' formato da oggetti
di tipo TableRow,
formati da celle che a
loro volta contengono
una sola View.
240
RelativeLayout
●
Il RelativeLayout permette ai figli di specificare
la loro posizione relativa a quella di un altro,
identificato tramite un ID.
241
GridLayout
●
●
Il GridLayout (disponibile a partire dalla 4.0)
consente di definire una griglia fatta di righe,
colonne e celle all'interno delle quali inserire i
widget.
La differenza con il TableLayout è che gli oggetti
all'interno delle celle si adattano alle variazioni
nell'interfaccia (es. Dimensione dei font) e utilizza
meno memoria.
242
Fragment
●
Sono stati introdotti a partire dalla 3.0
●
La classe base per i Fragments è android.app.Fragment
●
Facilitano il riuso di componenti in differenti layout: per
es. , si può definire un layout di tipo single-pane per
smartphone e multi-pane
tablet.
from: developer.android.com
243
Fragment
DetailFragment fragment = (DetailFragment)
getFragmentManager().
findFragmentById(R.id.detail_frag);
if (fragment==null || ! fragment.isInLayout()) {
// start new Activity
}
else {
fragment.update(...);
}
Esistono fondamentalmente due approcci:
●
●
Si utilizza una sola Activity che ad es. mostra due Fragment
per i Tablet ed un fragment per gli Smartphone
Facilitano il riuso di componenti in differenti layout: per es. ,
si può definire un layout di tipo single-pane per smartphone
e multi-pane tablet.
244
Creazione della UI
●
●
Mediante l'ADT è possibile creare l'intera UI della
nostra applicazione, con i layout, i widget e le
altre risorse, senza scrivere alcuna riga di codice
Esistono anche altri tool di supporto tra i quali:
●
DroidDraw per sviluppare la UI
●
Android UI Utils composte da:
UI Prototyping Stencils, per la prototipazione
● Android Asset Studio, per la generazione di
Icone
● Android Icon Templates, raccolta di Icon
Template in formato PhotoShop
●
245
Conclusioni
In questa lezione abbiamo visto le caratteristiche
di base della gestione dell'interfaccia utente da
parte di Android.
In particolare abbiamo visto l'organizzazione
gerarchica degli oggetti e i 5 principali tipi di layout
usati per disporre gli oggetti sullo schermo.
246
Sistemi Embedded - Android
Lezione n. 13:
Memorizzazione di dati
Introduzione
In questa lezione vedremo quali sono i metodi
principali messi a disposizione da una
applicazione Android per memorizzare dei dati in
maniera
permanente
e
successivamente
recuperarli.
Memorizzazione di dati
●
●
●
Un tipico sistema operativo per PC fornisce un filesystem comune che ogni applicazione può usare per
memorizzare e rileggere file che a seconda dei
permessi possono essere anche letti da altre
applicazioni.
Android usa un approccio diverso: tutti i dati delle
applicazioni, inclusi i file, sono privati di quella
applicazione.
Esistono dei meccanismi mediante i quali una
applicazione può condividere i propri dati con le
altre.
Meccanismi di memorizzazione
Android fornisce 6 meccanismi per memorizzare e
recuperare dati.
Il loro utilizzo dipende da tre da 2 aspetti
fondamentali:
●
●
I dati devono essere privati oppure possono essere
accessibili da altre applicazioni
I dati richiedono molto oppure poco spazio
Meccanismi di memorizzazione
Questi meccanismi sono:
●
Shared Preferences (dati pubblici/privati)
●
Internal Storage (dati privati)
●
External Storage (dati pubblici)
●
SQLite Database (dati strutturati privati)
●
Rete (web service)
●
Content Provider (dati privati accessibili)
Preferences 1/3
●
●
●
Una applicazione può scrivere e leggere valori
(detti ”Preferences”) condivisi con altre
applicazioni dello stesso package (”shared
preferences”) oppure privati dell'Activity.
Per Preferences si intendono le informazioni di
personalizzazione di una applicazione come
per es. il colore di sfondo, i tipi di carattere, la
suoneria predefinita...
Tali Preferences possono essere definite
tramite codice oppure mediante uno specifico
file xml da salvare nella cartella res\xml
Preferences 2/3
●
●
Per scrivere e leggere le shared preferences si
usa il metodo getSharedPreferences().
Per scrivere e leggere le preferences private si
usa il metodo getPreferences().
Preferences 3/3
E' possibile definire le seguenti preferences:
●
CheckBoxPreferences
●
DialogPreferences
●
EditTextPreferences
●
ListPreferences
●
RingtonePreferences
Preferences 4/4
<PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android"
android:key="first_preferencescreen">
<CheckBoxPreference
android:key="wifi enabled"
android:title="WiFi" />
<PreferenceScreen
android:key="second_preferencescreen"
android:title="WiFi settings">
<CheckBoxPreference
android:key="prefer wifi"
android:title="Prefer WiFi" />
... altre preferences ...
</PreferenceScreen>
</PreferenceScreen>
Internal Storage 1/3
●
I file creati da un'applicazione sono salvati
all'interno della directory
data/data/<package>/
●
●
●
●
Soltanto l'app può scrivere all'interno di questa
cartella.
E' però possibile creare sottocartelle all'interno
di essa nelle quali le altre applicazioni possono
leggere e scrivere.
Un'applicazione può scrivere e leggere file
locali usando i metodi openFileOutput() e
openFileInput() con nome locale e percorso.
Internal Storage 2/3
●
Se ci sono file statici inseriti nel progetto sotto
res/raw/, bisogna accedervi usando il metodo
openRawResource().
Internal Storage 3/3
I parametri utilizzabili sono:
●
●
●
●
MODE_PRIVATE – Nessun accesso dalle altre app
MODE_WORLD_READABLE – Sola lettura pe le
altre app
MODE_WORLD_WRITABLE – Accesso in
scrittura per le altre app
MODE_WORLD_READABLE |
MODE_WORLD_WRITABLE – Accesso in
lettura / scrittura per le altre app
External Storage 1/4
●
●
●
Un dispositivo Android dispone di un External
Storage, tipicamente una SD card, rimovibile o
meno
Tutti i file e le directory salvate all'interno dalla SD
sono accessibili da parte di tutte le app
Per poter accedere in lettura non è necessario
specificare alcun permission, mentre in scrittura è
necessario specificare il permesso:
android.permission.WRITE_EXTERNAL_STORAGE
●
Per ottenere la root della memoria esterna:
File sdcardDir = Environment.getExternalStorageDirectory();
External Storage 2/4
Prima di procedere nelle operazioni di lettura/scrittura sulla SD card
è necessario verificarne l'accessibilità mediante un apposito
controllo:
boolean mExternalStorageAvailable = false;
boolean mExternalStorageWriteable = false;
String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state)) {
mExternalStorageAvailable = mExternalStorageWriteable = true;
} else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
mExternalStorageAvailable = true;
mExternalStorageWriteable = false;
} else {
mExternalStorageAvailable = mExternalStorageWriteable = false;
External Storage 3/4
●
Per accedere a file privati sulla SD card si utilizza:
getExternalFilesDir() per API level ≥8
getExternalStorageDirectory() per API level < 8
●
Nel primo caso i file saranno creati all'interno della SD card
nella directory:
/Android/data/<package_name>/files/
●
I file così creati sono file privati dell'app
●
”Tipicamente” non dovrebbero essere visibili alle altre app.
●
Non esiste alcuna garanzia di sicurezza per questi file
●
Se l'app viene rimossa questi file saranno cancellati.
External Storage 4/4
●
●
Sulla SD card possono essere disponibili delle aree condivise
all'interno delle qualsi salvare file pubblici:
DIRECTORY_MUSIC, DIRECTORY_PICTURES,
DIRECTORY_RINGTONES...
Per accedere a file condivisi sulla SD card si utilizza:
getExternalStoragePublicDirectory() per API level ≥8
getExternalStorageDirectory() per API level < 8
●
Nel primo caso i file saranno creati all'interno della SD card
nella directory predefinita per il tipo di file
File path = Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_PICTURES);
●
Nel secondo caso si dovrà esplicitare il path da usare.
SQLite
●
●
●
●
●
Android supporta il sistema di database SQLite.
SQLite è open source, supporta le funzionalità
standard dei database relazionali e richiede
pochissima memoria a runtime (circa 250
KBytes)
Supporta i tipi di dato TEXT, INTEGER e REAL
Per utilizzare SQLite in Android non è
necessario alcun tipo di installazione o
configurazione.
Un database SQLite è privato: pertanto se una
app vuole esporne il contenuto dovrà farlo
mediante i Content Provider
SQLite
●
●
●
●
Il package android.database contiene tutte le
classi generali per operare con il database
Il package android.database.sqlite contiene le
classi specifiche di sqlite.
Android include nell'SDK il tool sqlite3, che
permette di visualizzare il contenuto delle
tabelle, eseguire comandi SQL ed effettuare sui
database SQL altri tipi di operazioni.
Tutti i database sul dispositivo sono
memorizzati nella directory
/data/data/<NOME_PACKAGE>/databases
SQLiteOpenHelper
●
●
●
●
La classe che dovrà gestire il nostro database è
ereditata da SQLiteOpenHelper
Normalmente si sovrascrivono i metodi
onCreate() per creare il database e
onUpgrade() per aggiornare il database in caso
di modifiche nel suo schema.
Come primary key delle tabelle si utilizza ”_id”.
Una buona pratica è quella di definire classe
per ciascuna Tabella del database con almeno i
due metodi onCreate() e onUpdate().
Cursor
●
●
●
●
Il Cursor è l'oggetto restituito dall'esecuzione di una
query e punta all'insieme dei risultati della query
Per conoscere il numero degli elementi si utilizza il
metodo count()
Per navigare tra i risultati si usano i metodi
moveToFirst(), moveToNext() e isAfterLast()
Per accedere ai dati del Cursor si utilizzano i metodi
getLong(indiceColonna) e getString(indiceColonna)
SQLiteDatabase 1/
●
●
●
SQLiteDatabase è la classe base mediante la quale
opereremo con il nostro database
Fornisce i metodi insert(), update() e delete()
Il metodo execSQL() ci permentte di eseguire direttamente
del codice SQL (con dei limiti)
db.execSQL("CREATE TABLE customer (_id INTEGER PRIMARY
KEY NOT NULL, name TEXT NOT NULL, address TEXT);");
●
Il metodo rowQuery() esegue una query SQL e restituisce
un oggetto Cursor
Cursor mCursor = db.rawQuery(”SELECT * FROM customer
WHERE _id = 1;”, null);
SQLiteDatabase 2/
●
Il metodo query() restituisce un oggetto Cursor
sull'insieme dei risultati
Cursor query (String table, String[] columns, String
selection, String[] selectionArgs, String groupBy, String
having, String orderBy, String limit)
Content Provider
●
●
●
●
Se si vogliono rendere pubblici dei dati bisogna
creare un Content Provider.
Questo oggetto permette di memorizzare dati
accessibili da tutte le applicazioni.
E' l'unico modo attraverso il quale package
diversi possono condividere dati.
Android di serie fornisce Content Provider per i
tipi di dati più comuni (es. contatti o file
multimediali).
Interrogare un Content Provider
●
●
●
Il modo nel quale un Content Provider
memorizza i dati è specifico
dell'implementazione, ma tutti i Content
Provider devono rispettare una convenzione
comune per effettuare una query e restituire i
risultati.
Ogni Content Provider espone una stringa
(URI, Uniform Resource Identifier) univoco.
Un URI può indicare tutti gli oggetti di un certo
tipo oppure uno specifico record.
Sintassi dell'URI
●
A: prefisso standard (sempre uguale)
●
B: percorso completo della classe
●
C: percorso completo del tipo di dato
●
D: se presente è l'ID dello specifico record
Esempi di URI
è l'URI che
restituisce la lista di tutti i contatti sul
dispositivo.
●
content://contacts/people/
●
content://contacts/people/23
●
content://media/internal/images/
●
content://media/external/images/
è l'URI che
restituisce il contatto con ID=23
restituisce la
lista delle immagini memorizzate nel dispositivo
restituisce la
lista delle immagini contenute nella scheda di
memoria (es. SD-Card)
Content Provider - Permission
●
●
Il modello di sicurezza di Android richiede che
un'applicazione non possa eseguire una data azione
”sensibile” senza aver richiesto ed ottenuto la
relativa Permission
Tale richiesta deve essere dichiarata all'interno dell'
AndroidManifest.xml e viene gestita a runtime, ma è
durante l'installazione che l'utente concede o non
concede la Permission richiesta.
<uses-permission
android:name="android.permission.READ_CONTACTS">
</uses-permission>
Content Provider - Esempio
L'esempio seguente accede al Content ”Contatti”
elencando il contenuto
ContentResolver cr = getContentResolver();
Uri uri = Uri.parse("content://com.android.contacts/contacts"); );
Cursor cur = cr.query(uri, null, null, null, null);
if (cur.getCount() > 0) {
while (cur.moveToNext())
{
String id = cur.getString(
cur.getColumnIndex(ContactsContract.Contacts._ID));
String name = cur.getString(
cur.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));
}
}
cur.close();
Rete
Infine non bisogna dimenticare che ovviamente i
dati oltre che sul dispositivo possono essere
memorizzati sulla rete.
I package utili a questo scopo sono:
java.net.*
e
android.net.*
Conclusioni
In questa lezione abbiamo visto gli strumenti
messi a disposizione da Android per la
memorizzazione permanente dei dati: le
Preferences, i File, i Database, i Content Provider
e ovviamente la rete.
Sistemi Embedded - Android
Lezione 14:
Location, Maps, Servizi di
Sistema
Introduzione
In questa lezione ci occuperemo di analizzare due
casi d'uso che fanno uso dei servizi di
localizzazione e della Google Maps
LocationManager Project
Nel primo caso d'uso svilupperemo un progetto
che ci permette di analizzare le potenzialità del
LocationManager di Android
LocationManager 1/2
●
●
●
●
LocationManager è una classe che permette di
accedere al system location service consentendo
di ricevere notifiche sulla posizione del disposivo
Permette ad una applicazione di ricevere
aggiornamenti periodici della posizione del device
Può invocare un Intent nel caso in cui il dispositivo
si trova in una particolare posizione
Per accedere a questo servizio si usa:
public abstract getSystemService(String name)
In cui name assume il valore
Context.LOCATION_SERVICE
LocationManager 2/2
●
●
●
●
Il LocationManager ottiene le informazioni della
posizione mediante i LocationProvider disponibili
all'interno del sistema: al momento esistono
provider basati su GPS o sulla rete WIFI
La scelta del provider dipende dai particolari criteri
richiesti dalla nostra applicazione, per es.
accuratezza, potenza, velocità, costo, altitudine.
Per essere notificati sulla posizione è necessario
definire una istanza dell'interfaccia
LocationListener
Location Manager e LocationListener sono definiti
all'interno del package android.location
Location Listener
●
Per ricevere una notifica da parte del provider
prescelto è necessario definire il seguente metodo:
public void requestLocationUpdates(String provider,
long minTime, float minDistance, LocationListener
listener)
● LocationListener rappresenta una interfaccia che
prevede la definizione di una serie di operazioni,
tra cui:
●
onLocationChanged()
●
onProviderEnabled()
●
onStatusChanged()
●
onProviderDisabled()
LocationManager Codice 1/2
LocationManager locationManager = (LocationManager)
getSystemService(Context.LOCATION_SERVICE);
locationManager.requestLocationUpdates(LocationManager.GPS
_PROVIDER, 0,0,listenerFine);
●
●
●
Mediante questo codice il LocationManager
consente di registrare il LocationListener
listenerFine rispetto al GPS_PROVIDER
Avremmo potuto registrarlo anche sul
NETWORK_PROVIDER
Avremmo potuto anche invocare la più generica
locationManager.requestLocationUpdates(
locationManager.getBestProvider(fineCriteria, true),
0, 0, listenerFine);
LocationManager Codice 2/2
new LocationListener() {
@Override
public void onLocationChanged(Location location) {}
@Override
public void onProviderDisabled(String provider) {}
@Override
public void onProviderEnabled(String provider) {}
@Override
public void onStatusChanged(String provider, int status,Bundle
extras) {} }
AndroidManifest.xml
●
Per poter usufruire dei servizi di notifica è
necesserio richiedere il ”permesso” mediante il
seguente codice:
<uses-permission android:name=
"android.permission.ACCESS_FINE_LOCATION" />
●
●
In questo caso stiamo richiedendo di accedere
alle informazioni di localizzazione in maniera
precisa (FINE), utilizzando quindi il GPS
In alternativa avremmo potuto richiedere il
permesso ACCESS_COARSE_LOCATION per
accedere alle informazioni di localizzazione
(meno precise) fornite dalla rete WIFI
LocationManager e ADT
●
Una caratteristica di questa applicazione è
rappresentata dalla possibilità di interagire con
il dispositivo virtuale mediante l' Emulator
Control
●
E' possibile inviare
informazioni
all'AVD anche nel
formato GPX (GPS
Exchange Format)
e KML (Keyhole
Markup Language)
OnLocationChanged 1/3
@Override
public void onLocationChanged(Location location) {
Log.i(LOG_TAG,location.getLatitude()
+":"+location.getLongitude());
Toast.makeText(LocationManagerTest.this,location.getLatitude()
+":"+location.getLongitude(), Toast.LENGTH_SHORT).show();
}
●
In questo caso onLocationChanged registra i
valori relativi alla nuova Location mediante un Log
e la visualizzazione di un Toast
OnLocationChanged 2/3
onLocationChanged 3/3
●
●
●
Una seconda particolarità di questa applicazione è
la costituita dal fatto che anche quando la nostra
Activity non si trova nel ForeGround rimane
comunque in ascolto della possibile variazione di
posizione
Ciò significa che l'Activity riceve comunque le
notifiche da parte del LocationManager pur
essendo in background
Se questo comportamento non è richiesto da parte
della nostra applicazione è conveniente intervenire
evitando in tal modo il consumo della batteria
removeUpdates
●
Per interrompere le notifiche dovremo quindi
richiamare removeUpdates in corrispondenza del
metodo onPause()
@Override
protected void onPause() {
locationManager.removeUpdates(locationListener);
super.onPause();
}
●
Per consentire alla nostra applicazione di ricevere
nuovamente le notifiche non appena tornerà in
ForeGround dovremo invocare
locationManager.requestLocationUpdates
all'interndo del metodo onResume()
Google Maps API Project
Nel second caso d'uso svilupperemo un progetto
basato sulle Google Maps API mediante il quale
effettueremo alcuni test sulla geolocalizzazione in
Android
Google Map API 1/3
●
●
●
Per sviluppare un progetto Android che
interagisce con le Map di Google è necessario
utilizzare le Google Maps API
E' necessario creare un AVD ed un progetto
che tengano conto del particolare target di
riferimento (stiamo utilizzando librerie esterne
ad Android standard
Verifichiamo la disponibilità di queste librerie
lanciando il tool ”Android SDK and AVD
Manager” ed eventualmente provvediamo alla
loro installazione
Google Maps API 2/3
Google Maps API 3/3
●
Dopo aver installato le
librerie necessarie i
nuovi target saranno
finalmente disponibili in
fase di creazione di un
nuovo progetto Android
map key 1/4
●
●
●
●
Per poter utilizzare le Google Maps API è
necessario disporre di una map-key
Tale codice sarà associato al certificato che
utilizziamo per firmare la nostra applicazione
E' necessario disporre di una chiave per il
certificato di debug ed una per il certificato di
release
Di seguito vedremo come ottenere il codice per
il certificato di debug
map key 2/4
●
●
Il primo passo consiste nell'individuare dove si
trova il keystore
Per far questo, in Eclipse, andiamo su Window|
Preferences|Build
map key 3/4
●
Facendo riferimento al keystore eseguiamo il
seguente comando:
keytool -list -alias androiddebugkey -keystore <keystore>
-storepass android -keypass android
●
Il risultato di questo comando sarà la
visualizzazione dell'MD5
Tipo keystore: JKS
Provider keystore: SUN
Il keystore contiene 1 entry
androiddebugkey, 11-mar-2011, PrivateKeyEntry,
Impronta digitale certificato (MD5):
94:1E:43:49:87:73:BB:E6:A6:88:D7:20:F1:8E:B5:98
map key 4/4
●
Accedendo alla pagina:
http://code.google.com/android/maps-api-signup.html
●
Dopo aver copiato la stringa MD5 nell'apposito spazio
ed accettato la licenza d'uso possiamo finalmente
generare l'API key
main.xml
●
L'ultimo passo consiste nel creare e/o
modificare il layout dell'applicazione inserendo
una WebView come desritto di seguito:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
●<com.google.android.maps.MapView
spèiega
android:id="@+id/mapView" android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:apiKey="0Zn3QJYynsgECUjkilDgQwp91xUczVAWg0
vo4IA" />
</LinearLayout>
AndroidManifest.xml
<uses-library android:name="com.google.android.maps" />
<uses-permission android:name=
"android.permission.INTERNET"></uses-permission>
<uses-permission android:name=
"android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name=
"android.permission.ACCESS_FINE_LOCATION"/>
●
Tra le definizioni più importanti presenti
all'interno del file manifest ci sono i permessi e
la libreria di google maps
Google Maps demo
requestWindowFeature(Window.FEATURE_NO_TITLE);
setContentView(R.layout.main);
mapView = (MapView) findViewById(R.id.mapView);
mapView.setClickable(true);
mapView.setBuiltInZoomControls(true);
mapView.getController().setZoom(21);
mapView.setSatellite(true);
LocationManager locationManager = (LocationManager)
getSystemService(Context.LOCATION_SERVICE);
●
●
Il widget mapView è stato inserito in precedenza
all'interno del layout main
Non essendo stata definita alcuna posizione
iniziale l'applicazione visualizzerà la mappa di
default
Google Maps demo
●
La MapActivity richiede l'implementazione della
seguente funzione:
@Override
protected boolean isRouteDisplayed() {
return false;
}
●
●
Tale funzione permette di dichiarare se la
nostra applicazione utilizzerà informazioni di
routing o no
Come richiesto dalla licenza d'uso di Google
Maps non può essere omessa e la sua
eventuale assenza ci sarà comunicata in fase di
compilazione
Google Maps demo
new LocationListener() {
@Override
public void onLocationChanged(Location location) {
}
@Override
public void onProviderDisabled(String provider) {
}
@Override
public void onProviderEnabled(String provider) {
}
@Override
public void onStatusChanged(String provider, int status,Bundle extras) {
}
});
●
Come nel caso precedente definiamo i metodi
del LocationListener che intendiamo gestire
Google Maps demo
Esempio: quando il dispositivo si troverà in una
nuova posizione
●
Modificheremo il livello zoom
●
Aggiorneremo la visualizzazione della mappa
@Override
public void onLocationChanged(Location location) {
GeoPoint myGeoPoint = GeoPoint((int)(location.getLatitude()),
(int)(location.getLongitude()));
mapView.getController().setZoom(10);
mapView.getController().animateTo(myGeoPoint);
}
●
Anche in questo caso possiamo utilizzare l'ADT per
interagire con l'emulatore
Google Maps demo - Codice
●
Utilizziamo i seguenti
valori ed inviamoli
all'AVD
●
Sarà visualizzata la
seguente mappa:
I servizi di Sistema
●
●
Negli esempi proposti in precedenza si è fatto
più volte uso dei servizi di sistema.
Abbiamo sempre effettuato l'accesso con la
chiamata:
getSystemService()
che ci ha consentito di utilizzare uno specifico
Manager
●
Oltre a quelli già analizzati, come il
NotificationManager, l'AlarmManager
I servizi di Sistema
●
●
●
●
Power Service: per la gestione del risparmio
energetico. Si accede mediante
POWER_SERVICE
Key Guard Service: per la gestione del lock
della tastiera. Si accede mediante
KEYGUARD_SERVICE
Vibrator Service: per la gestione della
vibrazione del dispositivo. Si accede mediante
VIBRATOR_SERVICE
Alarm Service: per la gestione degli allarmi. Si
accede mediante ALARM_SERVICE
I servizi di Sistema
●
●
●
●
Audio Service: per la gestione delle risorse
audio. Si accede mediante AUDIO_SERVICE
Telephony Service: per la gestione di chiamate
ed SMS. Si accede mediante
TELEPHONY_SERVICE
Connectivity Service: per la gestione della rete.
Si accede mediante
CONNECTIVITY_SERVICE
WiFi Service: per la gestione della WIFI. Si
accede mediante WIFI_SERVICE
I servizi di Sistema
●
●
●
Accessibility Service: per la gestione eventi
GUI. Si accede mediante
ACCESSIBILITY_SERVICE
Input Method Service: per la gestione
dell'interattività. Si accede mediante
INPUT_METHOD_SERVICE
ClipBoard Service: per la gestione degli
appunti. Si accede mediante
CLIPBOARD_SERVICE
I Sensor Service 1/2
●
●
●
Rappresentano probabilmente i servizi più
specifici di Android
Si accede mediante SENSOR_SERVICE
E' possibile accedere ad una lunga lista di
sensori, tra cui l'accelerometro, il giroscopio e la
bussola.
I Sensor Service 1/2
TYPE_ACCELEROMETER Accelerometro.
TYPE_ALL Tutti.
TYPE_AMBIENT_TEMPERATURE Temperatura
TYPE_GRAVITY Gravità.
TYPE_GYROSCOPE Giroscopio
TYPE_LIGHT Luminosità
TYPE_LINEAR_ACCELERATION Accelerazione lineare.
TYPE_MAGNETIC_FIELD Intensità campo magnetico
TYPE_PRESSURE Pressione
TYPE_PROXIMITY Prossimità
I Sensor Service 2/2
TYPE_RELATIVE_HUMIDITY Umidità
TYPE_ROTATION_VECTOR Rotazione vettoriale
TYPE_ORIENTATION (Bussola) Deprecato
I Sensor Service
@Override
protected void onResume() {
super.onResume();
mSensorManager.registerListener(this,
mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
SensorManager.SENSOR_DELAY_FASTEST);
mSensorManager.registerListener(this,
mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD),
SensorManager.SENSOR_DELAY_FASTEST);
mSensorManager.registerListener(this,
mSensorManager.getDefaultSensor(Sensor.TYPE_TEMPERATURE),
SensorManager.SENSOR_DELAY_FASTEST);
}
@Override
protected void onStop() {
mSensorManager.unregisterListener(this);
super.onStop();
}
Sistemi Embedded per il Mobile Multimedia
Ultime novità in
Android
Android 4.1 – Jelly Bean
●
Maggiore reattività grazie all'integrazione del
Project Butter (V-Sync ottimizzato e sincronizzato
al tocco)
●
Supporto al Multi-Tasking
●
Crittografia delle app
●
Aggiornamenti incrementali delle apk
●
Offline voice typing
●
Google Now
●
Notifiche
Android 4.1 – Jelly Bean
●
●
●
●
Google Cloud Messaging (GCM)
è un nuovo servizio che permette
agli sviluppatori di inviare brevi
messaggi alle loro applicazioni
alle loro applicazioni Android
GCM non garantisce la consegna dei messaggi
Non è necessario che l'Applicazione sia attiva per
ricevere il messaggio
All'arrivo di un messaggio GCM l'App viene
risvegliata mediante un Intent Broadcast
http://developer.android.com/guide/google/gcm/gcm.html
Android 4.1 – Jelly Bean
Android 4.2 – Jelly Bean
●
Gestione della Multi-utenza (al momento solo per
Tablet)
![Programmare APP su Android [40 ore]](http://s1.studylibit.com/store/data/005864255_1-c61abb8781bb920e40e378c560189f2e-300x300.png)
