ANDROID Introduzione alla programmazione per applicativi Android - Dott. Ing. Ivan Ferrazzi

 
ANDROID Introduzione alla programmazione per applicativi Android - Dott. Ing. Ivan Ferrazzi
Dott.Ing.Ivan Ferrazzi

                         ANDROID

                           Introduzione
                                alla
                         programmazione
                          per applicativi
                              Android

                          Dott. Ing. Ivan Ferrazzi
                           V1.1 del 05/08/2013

                                    1/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.Ing.Ivan Ferrazzi

              Il servizio è attualmente in esecuzione.
       Destroyed
              Il servizio viene terminato e non ha più bisogno di esistere.

                                         8/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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 esempio
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Dott.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/78
Puoi anche leggere
DIAPOSITIVE SUCCESSIVE ... Annulla