ANDROID Introduzione alla programmazione per applicativi Android - Dott. Ing. Ivan Ferrazzi
←
→
Trascrizione del contenuto della pagina
Se il tuo browser non visualizza correttamente la pagina, ti preghiamo di leggere il contenuto della pagina quaggiù
Dott.Ing.Ivan Ferrazzi
ANDROID
Introduzione
alla
programmazione
per applicativi
Android
Dott. Ing. Ivan Ferrazzi
V1.1 del 05/08/2013
1/78Dott.Ing.Ivan Ferrazzi
Copyright ©2013 Dott.Ing. Ivan Ferrazzi
Permission is granted to copy, distribute and/or modify this
document under the terms of the GNU Free Documentation
License, Version 1.2 or any later version published by the
Free Software Foundation; with no Invariant Sections, no
Front-Cover Texts, and no Back-Cover Texts.
2/78Dott.Ing.Ivan Ferrazzi
Indice generale
INTRODUZIONE....................................................................................................5
Installazione dell'ambiente di lavoro...............................................................5
Configurazione dell'ambiente di lavoro............................................................6
Concetti base...................................................................................................7
Activity........................................................................................................................................7
Intents..........................................................................................................................................7
Service.........................................................................................................................................7
Un primo progetto...............................................................................................9
Creiamo il nostro progetto...............................................................................9
Compilare il progetto.....................................................................................11
Installare l'applicazione.................................................................................11
Installazione su dispositivi virtuali...........................................................................................11
Installazione su dispositivi reali................................................................................................12
File presenti all'interno di un progetto...........................................................12
local.properties..........................................................................................................................12
project.properties.......................................................................................................................13
AndroidManifest.xml................................................................................................................13
res/values/strings.xml................................................................................................................14
res/layout/main.xml...................................................................................................................15
gen/com/example/myfirstapp/R.java.........................................................................................16
I layout..............................................................................................................18
LinearLayout..................................................................................................18
RelativeLayout...............................................................................................19
ListView.........................................................................................................20
GridView........................................................................................................22
Oggetti di output...............................................................................................25
TextView........................................................................................................25
Struttura XML...........................................................................................................................25
ImageView.....................................................................................................26
Struttura XML...........................................................................................................................26
Oggetti di input..................................................................................................27
EditText.........................................................................................................27
Struttura XML...........................................................................................................................27
Codice Java...............................................................................................................................29
Button............................................................................................................31
Struttura XML...........................................................................................................................31
Codice Java ..............................................................................................................................32
Checkbox.......................................................................................................32
Struttura XML...........................................................................................................................32
Codice Java...............................................................................................................................33
RadioGroup e RadioButton.............................................................................34
Struttura XML...........................................................................................................................34
Codice Java...............................................................................................................................34
ToggleButton.................................................................................................34
Struttura XML...........................................................................................................................34
Codice Java...............................................................................................................................35
Spinner..........................................................................................................35
Struttura XML...........................................................................................................................35
3/78Dott.Ing.Ivan Ferrazzi
Codice Java...............................................................................................................................36
Le Activity in dettaglio.......................................................................................37
I metodi per il cambio degli stati...................................................................37
Da starting a running.................................................................................................................37
Da running a paused..................................................................................................................37
Da paused a running..................................................................................................................37
Da paused a stopped..................................................................................................................37
Da stopped a running................................................................................................................37
Da paused a destroyed...............................................................................................................38
Da stopped a destroyed.............................................................................................................38
I View.............................................................................................................39
Esempio: utilizzo Activity...............................................................................39
Esempio: passaggio informazioni tra Activity................................................42
Salvare e recuperare i dati................................................................................49
Salvare e recuperare copie di dati.................................................................49
Utilizzare SQLite.............................................................................................50
Animazione 2D..................................................................................................56
Nuovo progetto TestGame.............................................................................56
Come prima cosa creiamo un nuovo progetto come segue.......................................................56
Nuova superficie di visualizzazione...............................................................57
Gestione del ciclo di gioco.............................................................................59
Aggiungiamo l'iterazione con lo schermo......................................................62
Aggiungiamo un'immagine............................................................................63
Animiamo l'immagine....................................................................................65
Un'oggetto per lo sprite.................................................................................68
Colpire il nemico............................................................................................70
Effetti sonori..................................................................................................73
Google Play........................................................................................................76
Registrazione sviluppatore............................................................................76
Certificare le nostre applicazioni...................................................................76
Creare la nostra chiave privata..................................................................................................77
Configurazione del progetto......................................................................................................77
Creare la nostra release.............................................................................................................78
4/78Dott.Ing.Ivan Ferrazzi
INTRODUZIONE
Questo tutorial è stato realizzato per introdurre gli interessati all'interno del
mondo di sviluppo per applicazioni Android. Cercheremo di installare un
ambiente di lavoro idoneo allo sviluppo con Linux per poi continuare nella
realizzazione di un progetto. Come distribuzione abbiamo utilizzato Debian, ma
si potrà naturalmente utilizzare anche delle distribuzioni diverse come ad
esempio Ubuntu. Cercheremo di evitare l'utilizzo di Eclipse per riuscire ad
entrare nel vivo della programmazione e per capire al meglio tutti i passaggi
necessari.
Installazione dell'ambiente di lavoro
Per lo sviluppo di applicativi Android ci basiamo sul software di Android
per gli sviluppatori (Android Software Development Kit – SDK) che
possiamo scaricare al seguente indirizzo
http://developer.android.com/sdk/index.html
Consigliamo di scaricare il file bundle che contiene tutto quello che serve
(o quasi) per iniziare a programmare. Il file scaricato è un file compresso
(nel nostro caso adt-bundle-linux-x86.zip) che possiamo decomprimere
all'interno di una cartella creata per il nostro sistema, ad esempio /home/
{user}/android, oppure {SYSTEM_DIR}/Users/{user}/android, dove {user} è il
nome dell'utente che stiamo utilizzando.
5/78Dott.Ing.Ivan Ferrazzi
Configurazione dell'ambiente di lavoro
Come prima cosa aggiungiamo per Linux i seguenti percorsi alla nostra
variabile di ambiente PATH
/home/user/android/adt-bundle-linux-x86/sdk/tools
/home/user/android/adt-bundle-linux-x86/sdk/platform-tools
Per Windows aggiungiamo alla stessa variabile di ambiente i seguenti
percorsi utilizzando la seguente forma
set PATH=%PATH%;{SYSTEM_DIR}\Users\user\android\adt-bundle-windows-
x86\sdk\tools;{SYSTEM_DIR}\Users\user\android\adt-bundle-windows-
x86\sdk\platform-tools
Per poter compilare i nostri progetti utilizzeremo il programma ant, un
compilatore basato su Java, simile al make, che utilizza file XML al posto di
file ″Makefile″ (utilizzati da make). Per questo motivo è indispensabile avere
sulla propria macchina anche una Java Development Kit (JDK).
Una volta installati su Windows sia ant che il JDK sarà necessario eseguire
le seguenti righe dal prompt dei comandi
set ANT_HOME=C:\Users\Ivan\android\ant
set JAVA_HOME=C:\Program Files\Java\jdk1.7.0_21
set PATH=%PATH%;%ANT_HOME%\bin
Inoltre abbiamo bisogno di uno spazio di lavoro (workspace) all'interno
del quale andremo a depositare tutti i nostri progetti. Creiamo quindi
semplicemente la nostra cartella di lavoro come segue
mkdir /home/user/android/workspace
per quanto riguarda gli ambienti Linux, mentre sotto Windows possiamo
creare la cartella
{SYSTEM_DIR}/Users/user/android/workspace
Facciamo ora partire l'ambiente Android SDK Manager con il seguente
comando
android update sdk
Questo ci metterà a disposizione le varie versioni di Android disponibile
che possiamo installa a piacere.
6/78Dott.Ing.Ivan Ferrazzi
Concetti base
Activity
Un'attività (activity) equivale ad un pannello contenitore che l'utente può
vedere. Un'applicazione è normalmente composta da più activities e
l'utente ha la possibilità di passare da un activity all'altra. Se prendiamo
come esempio un semplice gioco le activies necessarie saranno: activity
per la visualizzazione del menu iniziale, activity per il gioco e activity per
l'elenco dei punteggi.
Un'applicazione Android è composta da un'attività principale (main
activity) ed una serie di attività che possono essere richiamate a piacere.
Lo stato in qui si trova un'attività viene gestita dall'Activity Manager di
Android. Gli stati possibili sono:
Starting
L'attività viene fatta partire inizialmente caricando il necessario in
memoria.
Running
L'utente sta attualmente interagendo con l'attività in questione.
Paused
L'utente sta attualmente interagendo con un'altra attività.
Stopped
Se l'utente interagisce con un pannello sovrapposto all'attività
principale questa viene messa in modalità di pausa anche se in
parte visibile sullo schermo. Un'attività viene definita come stopped
quando l'utente esce dall'applicazione. L'applicazione non viene
rimossa completamente dalla memoria, ma rimane in attesa di
un'eventuale riavvio dell'applicazione stessa.
Destroyed
Solo se l'applicazione non viene utilizzata per un determinato
periodo di tempo questa verrà completamente rimossa dalla
memoria per liberare le risorse occupate.
Intents
Un'intenzione (intent) identifica un'azione che vogliamo svolgere
all'interno della nostra applicazione. Mediante intenzione riusciamo a far
capire al sistema come effettuare il passaggio da un'attività all'altra.
Service
Un servizio è simile ad un'attività con l'unica differenza che non contiene
componenti grafici in grado di interagire con l'utente, ma viene eseguito
in background (es. riproduttore di musica). La vita di un servizio viene
gestita dallo sviluppatore piuttosto che dal sistema Android. Non avendo
a disposizione un'interfaccia grafica gli stati di un servizio sono di meno.
Gli stati possibili sono:
Starting
Il servizio viene fatto partire inizialmente caricando il necessario in
memoria.
Running
7/78Dott.Ing.Ivan Ferrazzi
Il servizio è attualmente in esecuzione.
Destroyed
Il servizio viene terminato e non ha più bisogno di esistere.
8/78Dott.Ing.Ivan Ferrazzi
Un primo progetto
Vediamo ora come creare un semplice progetto iniziale con il quale potremmo
controllare il corretto funzionamento dell'intero ambiente di lavoro.
Creiamo il nostro progetto
Eseguiamo come prima cosa il seguente comando per verificare i così
chiamati target, che identificano le versioni di Android attualmente
disponibili all'interno del nostro ambiente.
android list targets
Il comando restituisce un risultato simile al seguente:
Available Android targets:
id: 1 or ″android-17″
Name: Android 4.2
Type: Platform
API level: 17
Revision: 1
Skins: WQVGA432, WVGA800 (default), QVGA, WXGA800-7in, WXGA720,
HVGA, WXGA800, WSVGA, WQVGA400, WVGA854
ABIs : armeabi-v7a
In base a queste informazioni creiamo il nostro progetto con il seguente
comando sotto Linux
android create project --target {target_id} --name MyFirstApp \
--path /home/user/android/workspace/MyFirstApp \
9/78Dott.Ing.Ivan Ferrazzi
--activity MainActivity --package com.example.myfirstapp
mentre per Windows modifichiamo il percorso alla cartella base con
android create project --target {target_id} --name MyFirstApp \
--path c:\Users\user\android\workspace\MyFirstApp \
--activity MainActivity --package com.example.myfirstapp
Dove target_id corrisponde all'id (numerico o testuale) presente nel
risultato precedente. Nel nostro caso scriviamo quindi su Linux:
android create project --target 1 --name MyFirstApp \
--path /home/user/android/workspace/MyFirstApp \
--activity MainActivity --package com.example.myfirstapp
su Windows
android create project --target 1 --name MyFirstApp \
--path c:\Users\user\android\workspace\MyFirstApp \
--activity MainActivity --package com.example.myfirstapp
Il sistema crea la cartella indicata con path all'interno della quale deporrà
una struttura di cartelle e file iniziale in base agli altri parametri forniti. I
file inseriti corrispondono al semplice esempio funzionante ″HelloWorld″.
Vediamo qui di seguito alcune delle risorse più importanti:
AndroidManifest.xml
Questo file contiene le caratteristiche base del nostro progetto,
come versione minima e massima supportata.
src/
Questa cartella contiene il sorgente dell'intero progetto. Con il
parametro package del comando precedente il sistema crea la
struttura a cartelle e sottocartelle conosciuta nel mondo Java.
All'interno dell'ultima cartella (quindi myfirstapp) il sistema crea il
file .java che rappresenta l'attività iniziale lanciata da Android
quando si clicca sull'apposita icona. Il nome del file è definito grazie
al parametro activity.
res/
Questa cartelle contiene delle sottocartelle che a loro volta
contengono le varie risorse della nostra applicazione.
drawable-*/
Contiene file immagine che possono essere utilizzati per
dispositivi con risoluzioni (densità di schermo) differenti.
layout/
Contiene i file che definiscono la disposizione dell'interfaccia
10/78Dott.Ing.Ivan Ferrazzi
grafica per l'utente finale.
values/
Questa cartella può contenere diverse risorse della nostra
applicazione come i file XML che definiscono le stringe o i
colori da utilizzare.
Compilare il progetto
Ora possiamo provare a compilare l'esempio di default messo a
disposizione dopo la creazione del nostro progetto iniziale. Ci spostiamo
all'interno della cartella del nostro progetto, quindi in
/home/user/android/workspace/MyFirstApp
ed eseguiamo il seguente comando
ant debug
che ci porterà ad avere il progetto compilato e pronto per Android
depositato all'interno della cartella bin del nostro progetto.
Installare l'applicazione
Installazione su dispositivi virtuali
Se non siamo in possesso di un dispositivo Android possiamo creare dei
dispositivi virtuali che ci permetteranno di emulare le versioni di Android
a piacere. Ora possiamo provare a compilare l'esempio di default messo
a disposizione dopo la creazione del nostro progetto iniziale.
Eseguiamo nuovamente l'ambiente Android SDK Manager con
android update sdk
e apriamo la finestra per la gestione dei dispositivi virtuali dal menu Tools
-> Manage AVDs...
Nella scheda Android Virtual Devices presente nella finestra clicchiamo
sul pulsane New... per aggiungere un nuovo dispositivo. Confermando
dovremo trovare il nuovo dispositivo nell'elenco della finestra. Clicchiamo
sul dispositivo per selezionarlo e premiamo sul pulsante Start... per
avviare l'emulatore.
A emulatore caricato ci spostiamo nella cartella root del nostro progetto e
digitiamo il seguente comando da terminale per installare il nostro
piccolo progetto sul dispositivo in questione.
11/78Dott.Ing.Ivan Ferrazzi
adb install bin/MyFirstApp-debug.apk
Ad installazione terminata troviamo l'applicazione MainActivity tra i
programmi installati. Clicchiamoci sopra per avviare ed ammirare la
nostra prima applicazione.
Per rimpiazzare un'applicazione attualmente presente sul dispositivo
usiamo il parametro -r come segue
adb install -r bin/MyFirstApp-debug.apk
Installazione su dispositivi reali
Se si possiede un dispositivo reale basta collegare il dispositivo al nostro
pc ed attivare la funzione USB debugging. Infine ci spostiamo nella
cartella root del nostro progetto e digitiamo il seguente comando da
terminale per installare il nostro piccolo progetto sul dispositivo in
questione.
adb install bin/MyFirstApp-debug.apk
Ad installazione terminata troviamo l'applicazione MainActivity tra i
programmi installati. Clicchiamoci sopra per avviare ed ammirare la
nostra prima applicazione direttamente dal nostro dispositivo.
In caso di necessità possiamo disinstallare il pacchetto con
adb uninstall com.example.myfirstapp
File presenti all'interno di un progetto
La programmazione per dispositivi Android si basa su dei file XML intuitivi
e facili da comprendere. Questo mette a disposizione la possibilità di
creare progetti adattabili a dispositivi dalle dimensioni diverse e di
gestire più lingue basandosi solamente sulle traduzioni dei testi
necessari.
local.properties
Questo file contiene il riferimento alla cartella che al suo interno ha il ADT
utilizzato in fase di creazione del progetto. Nel nostro caso dovremmo
trovare la riga
sdk.dir=/home/user/android/adt-bundle-linux-x86/sdk
su sistemi Linux e
sdk.dir={SYSTEM_DIR}\\Users\\user\\android\\adt-bundle-windows-x86\\sdk
su sistemi Windows, dove {SYSTEM_DIR} è la cartella di sistema di
Windows. Siccome il backslash (\) ha una funzionalità particolare sui
sistemi Windows è indispensabile sostituire ogni backslash con un doppo
backslash.
12/78Dott.Ing.Ivan Ferrazzi
Se trasferiamo un progetto da un computer all'altro dobbiamo verificare
la presenza della cartella specificata.
project.properties
Questo file contiene il target utilizzato per la creazione del nostro
progetto. Il contenuto potrebbe essere
target=android-17
L'id del target utilizzato può variare da computer a computer mentre
l'identificatore testuale (es. android-17) rimane invariato perché identifica
direttamente la versione SDK utilizzata. In base di compilazione ant
prende come punto di riferimento la versione SDK presente all'interno di
questo file. Per evitare quindi problemi in fase di compilazione dobbiamo
scaricare da Internet la versione SDK richiesta, oppure modificare il
contenuto di questo file con la versione di SDK installata sul nostro
computer.
AndroidManifest.xml
Questo file è il file base all'interno del quale si definisce da cosa è
composta l'applicazione, qual'è l'attività principale (quella che viene fatta
partire da Android quando clicchiamo sull'apposita icona) e quali
permessi sono necessari per l'avvio. Vediamo un semplice esempio
iniziale
Nel tag manifest si definiscono le proprietà principali dell'applicazione
come il percorso del pacchetto (package), la versione numerica
(android:versionCode) ed il nome della versione (android:versionName)
dell'applicazione.
Nel tag uses-sdk si definisce la versione più bassa funzionante per
l'applicazione (android: minSdkVersion) e quella utilizzata come target base
(android:targetSdkVersion). Si consiglia di utilizzare come versione target
quella più alta e di effettuare i test su tale versione.
13/78Dott.Ing.Ivan Ferrazzi
All'interno del tag application troviamo gli attributi android:label e
android:icon che identificano il nome dell'applicazione così come l'icona
da mostrare all'interno delle applicazioni del nostro Android. Il nome
definito mediante questo tag è quello che identifica l'applicazione
all'interno della scheda dell'applicazione del sistema Android. Per
garantire un determinato grado di flessibilità all'interno di questi attributi
non inseriamo dei valori statici ma un identificatore a delle risorse ben
precise all'interno della struttura del nostro progetto. L'identificatore ad
una risorsa è composto dalle seguenti parti:
@[posizione_risorsa]/[nome_risorsa]
La posizione della risorsa identifica il file XML o la cartella dalla quale
recuperare l'effettiva risorsa. La posizione string, ad esempio, recupera la
risorsa dal file XML res/values/strings.xml estrapolando il valore del tag
string identificato dal nome della risorsa. La posizione drawable invece
identifica un file (ad esempio .png) all'interno di una delle cartelle
res/drawable-* (ad esempio res/drawable-hdpi) create per rappresentare
l'immagine nelle giuste dimensioni su dispositivi diversi.
All'interno del tag application troviamo una serie di tag activity uno dei
quali si utilizza per specificare le caratteristiche delle singole attività
presenti all'interno della nostra applicazione. Gli attributi principali sono
android:name e android:label dove il primo identifica il nome della classe
che Android deve far partire come attività principale, mentre il secondo
ne identifica il titolo. Per far capire ad Android quale delle attività far
partire come prima è indispensabile inserire il blocco
all'interno dell'attività desiderata. Nel caso in cui il valore di android:name
non esistesse l'applicazione verrebbe compilata senza errori, ma non
saremmo in grado di avviare la nostra applicazione una volta installata
sul nostro Android. Il valore di android:label dell'attività principale è
quello utilizzato per il nome che identifica l'intera applicazione. In versioni
differenti di Android il valore di android:label presente nel tag application
e quello presente nel tag activity dell'attività principale possono essere
sostituiti l'uno con l'altro. Si consigli quindi di utilizzare lo stesso valore
per ambedue gli attributi.
res/values/strings.xml
Questo file contiene (o dovrebbe contenere) tutti i testi utilizzati
all'interno della nostra applicazione. Anche questo è un file XML ed ha la
seguente struttura
14/78Dott.Ing.Ivan Ferrazzi
Hello World!
MainActivity
Il tag root è resources che contiene una serie di tag string identificati
dall'attributo name. Il valore lo troviamo tra il tag di apertura e quello di
chiusura. Il valore di name è quello che si utilizza come nome della risorsa
negli indicatori di risorsa, ad esempio
@string/app_name
res/layout/main.xml
Il file in questione è un file XML che permette di definire il layout da
utilizzare per un'attività particolare. In questo caso definiamo il layout
dell'attività principale (main). Il nome che utilizziamo per salvare il file in
questione non è fondamentale visto che siamo noi a decidere quale file
utilizzare all'interno di quale attività con apposito metodo Java (che
vedremo più avanti). La struttura base di questo file potrebbe essere
come segue
Android premette di definire all'interno di questo file dei contenitori
(ViewGroup) in grado di contenere degli oggetti allineati in base alla
funzionalità del contenitore stesso. Il contenitore definito all'interno del
file è LinearLayout che permette di allineare gli oggetti contenuti al suo
interno in maniera orizzontale oppure verticale (android:orientation). La
larghezza (android:layout_width) e l'altezza (android:layout_height) del
contenitore principale dovranno corrispondere con le dimensioni dello
schermo messo a disposizione. Ecco perché si utilizza come valore
fill_parent per riempire completamente lo spazio presente.
Gli oggetti presenti all'interno di un contenitore possono essere altri
contenitori oppure degli elementi in grado di visualizzare qualcosa di
particolare (View) come pulsanti, testi, campi di input, immagini, ecc. Nel
nostro caso abbiamo l'oggetto TextView in grado di visualizzare il testo
presente in android:text nelle dimensioni definite grazie agli attributi
android:layout_width e android:layout_height. In larghezza utilizziamo tutto
lo spazio disponibile, mentre in altezza solo quello strettamente
necessario (wrap_content) per la visualizzazione del contenuto in
questione.
15/78Dott.Ing.Ivan Ferrazzi
gen/com/example/myfirstapp/R.java
Il file R.java è un file creato e modificato automaticamente in fase di
compilazione. Il contenuto di questo file non verrà quindi mai modificato
manualmente, ma è indispensabile comprenderne l'utilizzo per capire
meglio come si identifichi una risorsa all'interno della nostra applicazione.
Vediamo ora la struttura di questo file
/* AUTO-GENERATED FILE. DO NOT MODIFY.
*
* This class was automatically generated by the
* aapt tool from the resource data it found. It
* should not be modified by hand.
*/
package com.example.myfristapp;
public final class R {
public static final class attr {
}
public static final class drawable {
public static final int ic_launcher=0x7f020000;
}
public static final class layout {
public static final int main=0x7f030000;
}
public static final class string {
public static final int app_name=0x7f040001;
public static final int hello=0x7f040000;
}
}
La presenza di questa classe permette di identificare all'interno di
Android una qualsiasi risorsa presente in essa. Per recuperare la risorsa
che identifica il layout main possiamo scrivere
R.layout.main
L'utilizzo di questa forma lo scopriamo all'interno del prossimo file.
src/com/example/myfirstapp/MainActivity.java
Questo file contiene l'effettivo codice Java in gradi di far partire la nostra
applicazione. Nel nostro caso il file sarà simile al seguente:
package com.example.myfirstapp;
import android.app.Activity;
import android.os.Bundle;
public class MainActivity extends Activity {
/** Called when the activity is first called. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
16/78Dott.Ing.Ivan Ferrazzi
setContentView(R.layout.main);
}
}
Il file inizia con l'identificazione della posizione del file mediante comando
package ed importa le classi necessarie per il corretto funzionamento del
nostro codice con import. La classe android.app.Activity è indispensabile
per l'utilizzo delle attività. La classe Activity ha al suo interno i motodi
protected void onCreate(Bundle savedInstanceState);
protected void onStart();
protected void onRestart();
protected void onResume();
protected void onPause();
protected void onStop();
protected void onDestroy();
Il metodo che serve a noi è onCreate(Bundle) che viene fatto partire da
Android nel momento in cui lanciamo l'applicazione. Facciamo capire al
compilatore l'intenzione di sovrascrivere il contenuto del metodo della
superclasse (la classe Activity che estendiamo con il comando extends)
con l'annotazione @override.
La classe android.os.Bundle è indispensabile per permettere di
memorizzare eventuali informazioni prima che l'applicazione venga
interrotta da Android per poi riprendere le informazioni ad un prossimo
riavvio. Ecco perché troviamo Bundel savedInstanceState all'interno del
metodo onCreate().
Con la riga
super.onCreate(savedInstanceState);
richiamiamo il metodo in questione della superclasse, mentre la riga
setContentView(R.layout.main);
permette di indicare la risorsa che punta al file XML da utilizzare per il
layout desiderato.
17/78Dott.Ing.Ivan Ferrazzi
I layout
I layout di Android si dividono in layout come Linear Layout e Relative Layout e
view come List View e Grid View. Vediamo qui di seguito quando e come poterli
utilizzare.
LinearLayout
Questo tipo di layout permette di allineare gli elementi in una direzione,
verticale (vertical) o orizzontale (horizontal), utilizzando l'attributo
android:orientation. Vediamo un semplice esempio:Dott.Ing.Ivan Ferrazzi
android:layout_gravity="right"
android:text="@string/send" />
RelativeLayout
Questo tipo di ViewGroup ci permette di inserire elementi posizionandoli in
relazione agli elementi padre e/o agli elementi fratelli. Gli attributi che
possiamo utilizzare per il posizionamento relativo sono:
android:layout_alignParentTop
Se attivato (true) l'angolo alto del View in questione corrisponde all'angolo
alto del View padre.
android:layout_centerVertical
Se attivato (true) centra il View verticalmente all'interno del View padre.
android:layout_below
Posiziona l'angolo alto del View in questione al di sotto del View specificato
dal relativo id di risorsa.
android:layout_toRightOf
Posiziona l'angolo sinistro del View in questione a destra del View
specificato dal relativo id di risorsa.
Vediamo il seguente esempio:
19/78Dott.Ing.Ivan Ferrazzi
ListView
Questo tipo di ViewGroup è probabilmente l'elemento più utilizzato nel
mondo Android, perché è quello in grado di visualizzare dei contenuto
sotto forma di elenco. Vediamo nel seguente esempio come visualizzare
un'array contenente stringhe all'interno di un elenco.
Modifichiamo il file res/layout/main.xml come segue inserendo un ListView
Inoltre aggiungiamo il nuovo file res/layout/row.xml che contiene il layout
da utilizzare per ogni elemento del nostro elenco
Infine modifichiamo il file principale ListViewLoader.java come segue
package com.example.listviewloader;
import android.app.Activity;
import android.os.Bundle;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.view.View;
20/78Dott.Ing.Ivan Ferrazzi
public class ListViewLoader extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
ListView listView = (ListView)findViewById(R.id.listViewDemo);
String[] array = {"Antonio", "Giovanni", "Michele",
"Giuseppe", "Leonardo", "Alessandro"};
ArrayAdapter arrayAdapter = new ArrayAdapter(
this,
R.layout.row,
R.id.textViewList,
array
);
listView.setAdapter(arrayAdapter);
listView.setOnItemClickListener(
new OnItemClickListener() {
public void onItemClick(AdapterView parent, View v,
int position, long id) {
Toast.makeText(getApplicationContext(),
"Position:" + position,
Toast.LENGTH_SHORT).show();
}
}
);
}
}
All'interno di questo codice creiamo il ListView dall'id definito nel file xml
con
ListView listView = (ListView)findViewById(R.id.listViewDemo);
e l'array delle stringhe che vogliamo aggiungere con
String[] array = {"Antonio", "Giovanni", "Michele",
"Giuseppe", "Leonardo", "Alessandro"};
Infine creiamo un ArrayAdapter che aggiungiamo al ListView creato
precedentemente
ArrayAdapter arrayAdapter = new ArrayAdapter(
this,
R.layout.row,
R.id.textViewList,
array
);
listView.setAdapter(arrayAdapter);
I parametri necessari per creare un ArrayAdapter sono il Context (nel nostro
esempio this), il layout da utilizzare per le singole righe (R.layout.row), l'id
dell'elemento che vogliamo riempire all'interno dell'elenco
21/78Dott.Ing.Ivan Ferrazzi
(R.id.textViewList) e l'array popolato con le stringhe da visualizzare.
Siccome ArrayAdapter può essere utilizzato con tipi di dati diversi facciamo
capire al compilatore di voler utilizzare le stringhe mettendo l'indicatore
.
Per controllare su quale degli elementi l'utente ha cliccato aggiungiamo
un OnItemClickListener che ci permette di catturare l'evento click sul
rispettivo elemento.
listView.setOnItemClickListener(
new OnItemClickListener() {
public void onItemClick(AdapterView parent, View v,
int position, long id) {
Toast.makeText(getApplicationContext(),
"Position:" + position,
Toast.LENGTH_SHORT).show();
}
}
);
Il metodo onItemClick() cattura l'evento ricevendo i seguenti elementi
public void onItemClick(AdapterView parent, View v,
int position, long id) {
…
}
Il parametro parent contiene il ListView di riferimento, v identifica
l'elemento View (nel nostro caso TextView) all'interno del LinearLayout,
position determina la posizione dell'elemento View all'interno del
LinearLayout (partendo da 0), mentre id è l'id della riga di riferimento. Il
più delle volte position e id hanno lo stesso valore.
Per verificare i parametri inviati abbiamo utilizzato un Toast, una notifica
visualizzata sullo schermo del dispositivo come segue
Toast.makeText(getApplicationContext(),
"Position:" + position,
Toast.LENGTH_SHORT).show();
Il metodo makeText() necessita del Context, della stringa o riferimento ad
una stringa (R.string.testo) e della durata di visualizzazione che può
essere breve (Toast.LENGTH_SHORT) oppure lungo (Toast.LENGTH_LONG).
GridView
Anche questo fa parte della categoria dei ViewGroup e viene utilizzato per
visualizzare una griglia di informazioni. Nel seguente esempio
visualizzeremo il contenuto di un array.
Modifichiamo il file res/layout/main.xml come segue
22/78Dott.Ing.Ivan Ferrazzi
Gli attributi che abbiamo utilizzato sono:
android:numColumns
Permette di definire quante colonne visualizzare. Nel nostro caso
abbiamo usato auto_fit come valore che permette di inserire tante
colonne quanto è lo spazio disponibile.
android:gravity
Con questo attributo possiamo definire la disposizione del contenuto
della cella. Nel nostro caso usiamo center che permette di centrare il
contenuto sia verticalmente che orizzontalmente. E' possibile unire più
valori con il pipe “|”. Altri possibili valori possono essere: right, top, left,
bottom, center_vertical, fill_vertical, center_horizontal, fill_horizontal,
center, fill.
android:columnWidth
Permette di definire la larghezza fissa di ogni colonna.
android:stretchMode
Permette di definire come va riempito l'eventuale spazio vuoto
rimanente. Le opzioni possibili sono: none per disattivare l'allungamento
delle celle, spacingWidth per allargare lo spazio tra le celle, columnWidth per
allungare le colonne in maniera equa, oppure spacingWidthUniform per
allungare lo spazio tra le celle in maniera equa.
Il file GridViewActivity.java viene modificato come segue
package com.example.gridviewloader;
import android.app.Activity;
import android.os.Bundle;
import android.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.GridView;
import android.widget.TextView;
import android.widget.Toast;
import android.view.View;
import android.widget.AdapterView.OnItemClickListener;
public class GridViewActivity extends Activity {
GridView gridView;
static final String[] letters = new String[] {
"A", "B", "C", "D", "E",
23/78Dott.Ing.Ivan Ferrazzi
"F", "G", "H", "I", "J",
"K", "L", "M", "N", "O",
"P", "Q", "R", "S", "T",
"U", "V", "W", "X", "Y", "Z"};
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
gridView = (GridView) findViewById(R.id.gridView1);
ArrayAdapter adapter = new ArrayAdapter(
this,
android.R.layout.simple_list_item_1,
letters
);
gridView.setAdapter(adapter);
gridView.setOnItemClickListener(
new OnItemClickListener() {
public void onItemClick(AdapterView parent, View v,
int position, long id) {
Toast.makeText(getApplicationContext(),
((TextView) v).getText(),
Toast.LENGTH_SHORT).show();
}
}
);
}
}
Creiamo un ArrayAdapter riempiendolo con l'array numbers che contiene
una serie di stringe con
ArrayAdapter adapter = new ArrayAdapter(
this,
android.R.layout.simple_list_item_1,
numbers
);
Utilizziamo uno standard layout per elenco, ossia
android.R.layout.simple_list_item_1
Poi uniamo il tutto con
gridView.setAdapter(adapter);
Inoltre aggiungiamo un OnItemClickListener() per catturare i click sui vari
elementi all'interno del nostro GridView per mostrare poi all'interno di un
Toast il relativo elemento.
24/78Dott.Ing.Ivan Ferrazzi
Oggetti di output
Vediamo quali oggetti possiamo utilizzare per mostrare dei dati all'interno della
definizione del layout, quindi nel file XML, di un'attività.
TextView
Struttura XML
Questo oggetto permette di visualizzare del testo su riga singola o
multipla. L'oggetto viene aggiunto al file XML con il seguente tag
Questo tag ha come attributi una serie di possibilità che variano da
versione a versione. Gli attributi mostrati sono quelli più comuni e
vengono utilizzati per:
android:gravity Permette di definire l'allineamento del
testo.
android:maxLines Il massimo delle righe che l'oggetto può
25/78Dott.Ing.Ivan Ferrazzi
raggiungere.
android:singleLine Permette di attivare (true) o disattivare
(false) la modalità di riga singola.
android:lines Indica il numero di righe che l'oggetto
deve occupare come spazio, anche se il
testo è più corto.
android:textSize Definisce la dimensione del testo.
android:textStyle Permette di definire lo stile del testo
come bold, italic, bolditalic.
android:text Indica il testo da visualizzare.
ImageView
Struttura XML
Questo oggetto permette di visualizzare un'immagine. L'oggetto viene
aggiunto al file XML con il seguente tag
Questo tag ha come attributi una serie di possibilità. Noi ne visualizziamo
solo alcuni:
android:gravity Permette di definire l'allineamento
dell'immagine all'interno del contenitore.
android:src Permette di indicare l'immagine che
vogliamo visualizzare.
26/78Dott.Ing.Ivan Ferrazzi
Oggetti di input
Vediamo quali oggetti possiamo utilizzare all'interno della definizione del
layout, quindi nel file XML, di un'attività.
EditText
Struttura XML
Questo oggetto permette l'inserimento di testo come singola riga o come
blocco di testo. L'oggetto viene aggiunto al file XML con il seguente tag
Siccome il tag in questione rappresenta un oggetto dal quale sarà
possibile recuperare le informazioni inserite è indispensabile fornire un
identificatore con il quale poter identificare l'oggetto in attività
successive. Con l'attributo android:id definiamo il nome da utilizzare
come identificativo dell'oggetto stesso. Il simbolo @ identifica (come già
visto precedentemente) l'accesso ad una risorsa di Android, mentre la
parola id identifica il come utilizzare il valore che viene dopo lo slash ( /).
In questo caso diciamo ad Android di utilizzare il valore email_address
come identificatore, quindi id dell'oggetto che stiamo creando. Il + viene
utilizzato quando inizializziamo per la prima volta l'oggetto.
L'attributo android:hint permette di definire il testo che viene inserire nel
27/78Dott.Ing.Ivan Ferrazzi
campo prima di iniziare a scrivere. Nel momento in cui scriviamo questo
testo sparisce lasciando solamente il valore inserito.
Per definire il tipo di input da gestire o l'eventuale comportamento
dell'oggetto stesso durante l'inserimento utilizziamo l'attributo
android:inputType. Come input da gestire possiamo utilizzare:
″text″
Inserimento mediante tastiera normale.
″textEmailAddress″
Tastiera normale con simbolo @.
″textUri″
Tastiera normale con simbolo /.
″number″
Tastiera numerica.
″phone″
Tastiera numerica come per telefono.
Il comportamento si definisce con i seguenti valori:
″textCapSentences″
Capitalizza la prima lettera di ogni nuova frase.
″textCapWords″
Capitalizza la prima lettera di ogni parola.
″textAutoCorrect″
Attiva l'autocorrezione.
″textPassword″
I caratteri inseriti diventano dei punti.
″textMultiLine″
Permette di inserire del testo con interruzione di riga.
Possiamo combinare più caratteristiche all'interno di questo attributo
separando le varie parole chiave con il pipe (|) come segue:
Android ci permette di sostituire il pulsante INVIO presente nella tastiera
con un pulsante di azione a scelta. L'attributo che definiamo è
android:imeOptions che possiamo utilizzare con i valori actionSend (appare
il pulsante invia), actionSearch (appare il pulsante cerca), oppure
actionNone (disattiva l'azione). Vediamo un semplice esempioDott.Ing.Ivan Ferrazzi
android:imeOptions=″actionSend″ />
Codice Java
L'azione che si ottiene quando si preme sul pulsante definito con
android:imeOptions si può monitorare con un determinato listener, ossia
una particolare procedura in Java con la quale si rimane in ascolto di
eventuali azioni. Il listener che possiamo utilizzare è
OnEditorActionListener in grado di monitorare azioni su un TextEdit.
Andiamo a modificare i file come segue
res/values/strings.xml
Hello World!
MainActivity
Enter password
res/layout/main.xml
/src/com/example/myfirstapp/MainActivity.java
package com.example.myfirstapp;
import android.app.Activity;
import android.os.Bundle;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.TextView.OnEditorActionListener;
import android.view.KeyEvent;
import android.view.inputmethod.EditorInfo;
public class MainActivity extends Activity {
/** Called when the activity is first called. */
@Override
public void onCreate(Bundle savedInstanceState) {
29/78Dott.Ing.Ivan Ferrazzi
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
EditText editText = (EditText) findViewById(R.id.search);
editText.setOnEditorActionListener(
new OnEditorActionListener() {
@Override
public boolean onEditorAction(TextView v, int actionId,
KeyEvent event) {
boolean handled = false;
if (actionId == EditorInfo.IME_ACTION_SEND) {
TextView textView = (TextView) findViewById(R.id.show_text);
textView.setText(v.getText());
handled = true;
}
return handled;
}
}
);
}
}
Le parti aggiunte nei vari file sono quelle in grassetto. Abbiamo quindi
aggiunto una nuova stringa password_hint nel file res/values/strings.xml,
aggiunto un id al TextView e l'intero nuovo oggetto EditText nell'apposito
file res/layout/main.xml ed infine modificato il file MainActivity.java.
Dopo aver importato le classi necessarie abbiamo inserito un nuovo
blocco in grado di ascoltare l'azione su EditText per poi copiare il testo
inserito all'interno del TextView.
All'interno dell'attività abbiamo a disposizione il metodo findViewById() in
grado di recuperare un oggetto in base al nome della risorsa, ossia
R.id.[nome_identificativo]
Questo metodo può essere utilizzato solamente dopo che è stato creato il
layout dell'attività in questione. Ecco perché è fondamentale utilizzare il
metodo solo dopo il setContentView(). Altrimenti si cercherà di attingere
ad una risorsa non ancora definita.
Aggiungiamo quindi il listener con
editText.setOnEditorActionListener(...);
e ne definiamo il comportamento subito all'interno con
new OnEditorActionListener() {...}
All'interno di quest'ultima andiamo a sovrascrivere il metodo
onEditorAction(TextView, actionId, KeyEvent)
30/78Dott.Ing.Ivan Ferrazzi
che ci permetterà di recuperare l'oggetto sul quale è avvenuta l'azione
(TextView), cosa a scaturito l'evento (actionId) e l'evento del tasto che
abbiamo premuto (KeyEvent).
Il listener manda in esecuzione un'azione ogni volta che premiamo un
tasto della tastiera. Ecco perché dobbiamo utilizzare l'actionId per
verificare che il tasto premuto sia proprio quello definito all'interno
dell'oggetto in questione. Questa verifica la facciamo con
if(actionId == EditorInfo.IME_ACTION_SEND) {
...
}
Infine recuperiamo l'oggetto show_text e gli passiamo il testo (setText)
recuperato dall'oggetto TextView passato al metodo onEditorAction con
getText().
Button
Struttura XML
Un pulsante è composto da testo, da un'immagine o da entrambi e deve
essere in grado di far eseguire un codice quando l'utente ci clicca sopra.
Possiamo creare un pulsante utilizzando tre forme diverse. Per creare un
pulsante con all'interno del testo scriviamo
Se abbiamo bisogno di un pulsante con all'interno un'immagine e niente
testo scriviamo
Altrimenti possiamo scrivere il seguente tag per incorporare sia
immagine che testo
Possiamo posizionare l'immagine con android:drawableLeft,
android:drawableRight, android:drawableTop, oppure android:drawableBottom.
31/78Dott.Ing.Ivan Ferrazzi
All'interno di questi tag possiamo definire l'attributo android:onClick che
permette di definire il nome del metodo che verrà richiamato passandogli
View come parametro quando l'utente clicca sul pulsante stesso. Se
definiamo
cliccando sul pulsante Android eseguirà il seguente metodo che deve
essere presente all'interno dell'attività
public void showText(View view) {
...
}
Codice Java
E' possibile reagire alla pressione di un pulsante utilizzando un listener al
posto del android:onClick come segue
Button button = (Button) findViewById(R.id.button);
button.setOnClickListener(
new OnClickListener() {
public void onClick(View v) {
...
}
}
);
Per far funzionare questo codice è indispensabile creare l'oggetto Button
con l'id button
e di importare le classi necessarie nel file MyActivity.java con
import android.view.View;
import android.view.View.OnClickListener;
Checkbox
Struttura XML
I checkbox possono essere inseriti con il tag
32/78Dott.Ing.Ivan Ferrazzi
I vari attributi utilizzati dovrebbero essere ormai chiari.
Codice Java
La funzione che possiamo utilizzare per recuperare le informazioni di un
checkbox appena cliccato è la seguente
public void onCheckboxClicked(View view) {
boolean checked = ((CheckBox) view).isChecked();
if(view.getId() == R.id.checkbox_1) {
if(checked) {
...
}else{
...
}
}
}
Nella riga
boolean checked = ((CheckBox) view).isChecked();
convertiamo l'oggetto view nell'oggetto che interessa a noi, quindi
Checkbox, per poter poi utilizzare il rispettivo metodo isChecked() che
permette di verificare se il checkbox è attivo o meno.
Con il metodo getId() dell'oggetto view riusciamo a recuperare l'id in
questione che controlliamo nella riga
if(view.getId() == R.id.checkbox_1) { ... }
Nel caso in cui fosse necessario modificare lo stato del checkbox in fase
di visualizzazione (quando si mostrano delle impostazioni salvate
precedentemente) possiamo utilizzare i metodi setChecked(boolean)
oppure toggle().
Anche per questa parte di codice è indispensabile importare la seguente
classe
import android.widget.CheckBox;
import android.view.View;
33/78Dott.Ing.Ivan Ferrazzi
RadioGroup e RadioButton
Struttura XML
La struttura di tag che utilizziamo per definire dei radiobuttons che
appartengono allo stesso gruppo è la seguente:
Codice Java
La funzione che possiamo utilizzare per recuperare le informazioni di un
radiobotton appena cliccato è la seguente
public void onRadioButtonClicked(View view) {
boolean checked = ((RadioButton) view).isChecked();
if(view.getId() == R.id.maschio) {
if(checked) {
...
}
}
}
Anche per questa parte di codice è indispensabile importare la seguente
classe
import android.widget.RadioButton;
import android.view.View;
ToggleButton
Struttura XML
I ToggleBotton sono degli interruttori che possono essere accesi o spenti
cliccandoci sopra. Il tag che utilizziamo per definire questo oggetto èDott.Ing.Ivan Ferrazzi
android:textOn=″@string/text_on″
android:textOff=″@string/text_off″
android:onClick=″onToggleClicked″ />
Gli attributi android:textOn e android:textOff permettono di definire il testo
visualizzato quando il pulsante è acceso e quando è spento.
Codice Java
La funzione che possiamo utilizzare per recuperare le informazioni di un
togglebutton appena cliccato è la seguente
public void onToggleClicked(View view) {
boolean on = ((ToggleButton) view).isChecked();
if(on) {
...
}else{
...
}
}
Anche per questa parte di codice è indispensabile importare le seguenti
classi
import android.widget.ToggleButton;
import android.view.View;
Spinner
Struttura XML
Gli Spinner sono dei menu che mettono a disposizione le varie opzioni
all'interno di un pannello con gli elementi elencati dall'alto verso il basso.
Il tag che utilizziamo per definire questo oggetto è
Per popolare lo Spinner possiamo creare un file risorsa xml che salveremo
nella cartella res/values e che possiamo chiamare spinner.xml. Avremo
quindi il seguente file res/values/spinner.xml
Mercurio
Venere
Terra
Marte
35/78Puoi anche leggere
