T#002 – Creiamo il nostro primo programma per Android “Hello World!”

Ciao a tutti, eccoci con in nostro secondo tutorial dedicato al mondo della programmazione Android. Oggi vediamo come creare il nostro primo e semplice programma, il classico “Hello World”, ovviamente per dispositivi Android. Non fatevi ingannare dalla semplicità del primo progetto, oggi, infatti, studieremo insieme parecchi concetti molto importanti utili ad ogni programmatore Android e in particolare impareremo:

• come creare un nuovo progetto Android;
• a conoscere le componenti base di una applicazione Android;
• come sono organizzate le risorse all’interno del progetto;
• il significato e il contenuto dei file principali;
• come lanciare la nostra applicazione HelloWorld sull’emulatore;
• come lanciare HelloWorld in debug sul nostro telefono.

Creiamo un nuovo progetto Android

Partiamo con il nostro tutorial creando il nostro primo progetto Android. Naturalmente sarà, come detto, il classico “Hello World!“. Avendo installato su Eclipse il plugin ADT (Android Development Tools) abbiamo a disposizione uno nuovo tipo di progetto: “Android Project“. Lanciamo quindi il wizard di creazione di un nuovo progetto e scegliamo proprio la tipologia appena citata “Android Project“:

Nello wizard impostiamo i parametri come mostrato nello screenshot, ovvero:

• Project name: HelloWorld
• Application name: Hello World
• Package name: it.devapp.helloworld
• CreateActivity: HelloWorldActivity

Come si vede nello wizard vengono specificati vari parametri, molti dei quali familiari per chi già sviluppa in Java: il nome del progetto e il nome del package. Da notare la scelta del Build Target, ovvero viene chiesto di specificare la tipologia del dispositivo. Abbiamo scelto di realizzare un applicativo il cui target sono dispositivi su cui è montata la versione 2.2 del sistema operativo Android.

Nel campo “Min SDK Version” è però possibile specificare la minima versione dell’ SDK supportata: stiamo in questo caso affermando che la nostra applicazione ha come target dispositivi con Android 2.2, ma può girare anche su dispositivi con una versione di Android che va fino alla 1.6 inclusa.
Questa informazione è preziosa perchè sarà disponibile quando l’applicazione sarà pubblicata sull’Android Market: il creatore dell’applicazione avrà un numero di possibili utenti maggiori ampliando il range di SDK, e quindi device supportati. Quando un utente accede al Market dal proprio terminale, infatti, vedrà solo le applicazioni compatibili con la versione di Android che sta utilizzando, le altre applicazioni saranno nascoste in automatico dal sistema. Ovviamente sarà cura dello sviluppatore garantire che tale compabilità sia reale e non solo dichiarata.

Viene chiesto anche di specificare un nome per la Activity. Le Activity sono classi Java che estendeno android.app.Activity e costituiscono i mattoncini della GUI android, sono il corrispettivo della window di una applicazione desktop.

Premendo su “Finish” Eclipse popolerà automaticamente il progetto, inserendo le librerie di Android e la struttura di base dei progetti per questa piattaforma.

Viene creata anche la prima Activity del Progetto, col nome da noi specificato:

1
2
3
4
5
6
7
8
9
10
11
12
13

package it.devapp.helloworld;
 
import android.app.Activity;
import android.os.Bundle;
 
public class HelloWorldActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}

Componenti di una applicazione Android

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

• Activity;
• Content Provider;
• Broadcast Receiver;
• Service.

Activity

La Activity è il mattone alla base dell’interfaccia utente. E’ l’analogo della window di una applicazione desktop. E’ possibile avere Activity senza user interface, ma più probabilmente tale codice sarà sotto forma di Content Provider o servizio.

Content Provider

I Content Provider costituiscono un livello di astrazione per i dati memorizzati a livello di device e a disposizione di più applicazioni. Il modello di sviluppo Android incoraggia a rendere i dati disponibili alle altre applicazioni: un Content Provider fa proprio questo, pur lasciando il controllo completo di come i dati vengono acceduti.

Broadcast Receiver

Se un’applicazione deve ricevere e rispondere a un evento globale (arrivo di una chiamata o di un SMS) deve registrarsi come Broadcast Receiver. Un’applicazione si registra come ricevitore di Intent in diversi modi, come vedremo in seguito.

Intent

Gli intenti sono messaggi di sistema che girano all’interno del device e che notificano le applicazioni di vari eventi, tra cui:

• cambiamenti di stato hardware;
• dati in ingresso (è arrivato un nuovo SMS);
• eventi applicativi (la propria Activity è stata lanciata).

E’ possibile rispondere agli intenti o crearne di propri, per lanciare altre attività o per farsi notificare del verificarsi di certe situazioni (ad esempio è possibile lanciare un intento quando l’utente è più vicino di 100 metri a una certa locazione).

Service

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

• controllare se ci sono aggiornamenti per un feed RSS,
• riprodurre musica anche se la Activity di partenza non è più attiva.

Organizzazione delle risorse all’interno del progetto

Non appena creato il nostro primo progetto Android, HelloWorld, Eclipse ha creato per noi diversi file, oltre alla Activity iniziale. Ci ritroviamo diversi file, organizzati in una struttura piuttosto ordinata, di cui andiamo ora a spiegare il significato.

• AndroidManifest.xml: descrive la applicazione in sviluppo e quali componenti (Activity, Service e così via) la compongono
• default.properties, poco rilevante per noi, poichè serve esclusivamente al sistema di build automatico
• directory
• src: contiene i package e le classi della nostra applicazione
• assets: contiene risorse esterne necessarie all’applicazione (file audio, video, etc)
• res: contiene risorse esterne necessarie all’applicazione, ma in più presenta una speciale struttura predefinita; contiene infatti a sua volta alcune sottocartelle:
• drawable-hdpi, drawable-ldpi e drawable-mdpi, che contengono le immagini nelle 3 versioni per schermi a bassa densità, media densità e alta densità. Consultare Android Screen Support per maggiori informazioni su come Android supporti dispositivi che offrono un ampio range di screen size e risoluzioni
• layout: contiene il file main.xml utile per definire in modo dichiarativo il layout grafico dell’applicativo
• values: contiene il file strings.xml utilizzato per la localizzazione dell’applicativo
• gen: contiene la speciale classe chiamata R, abbreviazione di Resources. Invocando questa classe, infatti, è possibile richiamare via codice le risorse memorizzate sotto la directory res. La classe R viene generata automaticamente dal sistema e non deve mai essere modificata a mano.

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

Significato e contenuto dei file principali

AndroidManifest.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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

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

1
2
3
4
5

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

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

Come abbiamo visto esistono più file icon dentro le cartelle res/drawable corrispondenti alle varie risoluzioni, il file da usare viene scelto in base alla risoluzione del dispositivo usato.

Infine le righe

1
2
3
4

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

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

Lancio dell’applicazione sull’emulatore

Per lanciare la nostra applicazione in run creiamo una nuova Run Configuration. Scegliamo dal menu Run->Run Configurations…

Facciamo click su New Launch Configuration

Diamo un nome alla nuova configurazione di run e specifichiamo il nostro progetto. Lasciando valorizzato Launch Default Activity verrà eseguita la nostra HelloWorldActivity. Nel tab Target è possibile vedere su quale Android Virtual Device verrà lanciata la nostra applicazione se lasciamo come Target Selection Mode “Automatic”.

Facendo click su Run viene lanciato l’emulatore con la nostra applicazione running:

Se nel tab Target mettiamo come Target Selection Mode Manual e premiamo Run ci viene offerta la possibilità di specificare un altro AVD: questo è utile per testare la compatibilità della propria applicazione su differenti versioni di Android:

HelloWorld in debug sul tuo telefono

Per lanciare la propria applicazione in debug sul telefono è necessario seguire gli step seguenti:

1. Installiamo il Google USB Driver package

Lanciare l’AVD Manager, cliccare su Installed packages e poi su Update All…





Verifichiamo che Google USB Driver package abbia la spunta verde accanto e premiamo Install. Nel caso in cui i Driver USB forniti da Google non siamo sufficienti a far riconoscere al vostro PC il telefono consultate il sito del vendor specifico per il supporto.

2. Rendiamo la nostra applicazione debuggabile

Per farlo impostiamo nell’AndroidManifest l’attributo debuggable a true:

1 2 3

... ... <application android:icon="@drawable/icon" android:label="@string/app_name" android:debuggable="true"> ... ...

... ... <application android:icon="@drawable/icon" android:label="@string/app_name" android:debuggable="true"> ... ...

3. Abilitiamo il debugging sul nostro telefono

Sul nostro telefono clicchiamo su Settings -> Applications -> Development. Selezioniamo USB debugging. Selezioniamo anche Stay awake se vogliamo che lo schermo rimanga sempre attivo mentre eseguiamo il debug.




4. Colleghiamo il telefono al PC

Verifichiamo che nella barra delle notifiche compaia il simbolo USB a indicare che il telefono è collegato via usb ad un PC e il simbolo di Debug, a indicare che abbiamo abilitato il debugging sul device.




5. Lanciamo l’applicazione

Tasto destro sul progetto Debug As -> Android Application. Se il device è stato correttamente collegato al PC dovrebbe essere mostrato tra i Running Android device:





Selezioniamo il nostro device e premiamo ok. L’applicazione sarà lanciata sul telefono e se sono stati impostati dei breakpoint l’esecuzione si arresterà in corrispondenza di tali punti.





Da qui in poi la fase di debugging è esattamente uguale a quella di ogni altra applicazione Java.

Conclusioni

Con questo tutorial abbiamo visto come creare un HelloWorld Android usando il diffuso IDE Eclipse e utilizzando le librerie e i plugin messi a disposizione da Google. Nei prossimi tutorial ci addentreremo ben più a fondo nell’affascinante mondo della programmazione Android. Alla prossima!