Struttura di un'applicazione Android

di  Antonio Coschignano, sabato 22 maggio 2010
Un applicazione Android è costituita da diversi tipi di componenti che comprendono : codice sorgente Java, documenti XML, icone ed immagini, basi di dati e file binari di altro tipo. Tutti questi componenti vanno in un qualche modo assemblati fra di loro ed in base alla tipologia va inserito in un particolare punto del progetto. In quest'articolo tracceremo una panoramica sulla struttura dei componenti e i ruoli che assumono all'interno dell'applicazione.

Creazione di un nuovo progetto Android

Nell'affrontare gli argomenti faremo riferimento al Plugin ADT Eclipse per Android SDK, per l'installazione consultare Guida all'installazione dell'Android SDK. Creaiamo un progetto nuovo, selezionando File -> New Project -> Android Progect. Si aprira la finestra del Wizard:

New Android Project

Vediamo nel dettaglio i parametri che abbiamo specificato:
  • Project Name: è il nome del progetto che riguarda la cartella principale nella quale Eclipse distribuisce tutte le cartelle che compongono il progetto
  • Build Target: la versione della piattaforma Android OS
  • Application Name: questo è il nome dell'applicazione che poi vedremo visualizzato nell'emulatore (o dispositivo) accanto all'icona dell'applicazione
  • Package Name: il nome del package dell'applicazione, deve essere preceduto sempre dal suffisso com
  • Create Activity: il nome della classe che estende Activity. L'Activity come vedremo in seguito rappresenta il cuore dell'applicazione
  • Min SDK Version: siccome le versioni delle API di Android sono in continua evoluzione, dobbiamo specificare la versiona del set di API a partire dalla quale l'applicazione che stiamo implementando può funzionare
Il progetto che abbiamo appena creato di default implementa un'applicazione Android che visualizza il messaggio 'Hello World, ExampleActivity!':

New Android Project

Cercheremo adesso di fare un po di luce sull'intera struttura dell'applicazione, cercando di focalizzarci sugli aspetti fondamentali che riguardano l'implementazione di codice java e le risorse XML che è possibile definire, ed inoltre come fare interagire fra di loro queste tipologie di componenti.

Activity e risorse

L'Activity (android.app.Activity) rappresenta una delle classi fondamentali dell'architettura Android. Ogni applicazione deve contenere una specializzazionde di questa classe. Questo concetto - per chi proviene da esperienze di programmazione in J2ME (Java Micro Edition) - è molto simile alla classe MIDLet che ha un suo lifecycle (ciclo di vita) che viene gestito dalla piattaforma ma definito dallo sviluppatore che implementanda i metodi. In questa immagine viene riassunto il ciclo di vita di un'Activity:

Ciclo di vita di un'Activity

Per il momento è indispensabile capire che un' Activity rappresenta il punto di partenza, da dove si espande tutta la logica dell'applicazione con le sue diverse schermate e implementazioni di funzioni legate all'architettura. Ritornando al nostro progetto questa è l'Activity che ci viene generata in automatico dal plugin ADT:
package com.example;
import android.app.Activity;
import android.os.Bundle;
public class ExampleActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }
}
I sorgenti dell'applicazione vanno inserite nella cartella src/package/:

Sorgenti

Per quanto riguarda il ciclo di vita, in questo caso è stato ridefinito solo il metodo onCreate() che è il primo metodo che viene invocato dalla piattaforma Android non appena viene lanciata l'applicazione. Quindi è necessario affinchè l'applicazione viene visualizzata nel display del dispositivo. Gli altri metodi comunque rivestono un ruolo fondamentale per un corretto funzionamento dell'applicazione.

Le risorse

L'ambiente Android riprende il concetto di 'programmazione dichiarativa', dove alcune informazioni (risorse) vengono memorizzate in file di configurazioni esterni al codice. Ciò offre il vantaggio di non dover ricompilare il codice al fronte di semplici modifiche ad un file di configurazione. Le risorse sono contenute nella cartella res/ che assume questa struttura:

Package Explorer Res

Una risorsa può essere un'icona (o un'immagine qualsiasi), un documento XML, oppure un file binario che viene utilizzato nell'applicazione. Comunque in base al tipo di risorsa, corrisponde una cartella dove posizionare il file. Specifichiamo quali tipi di risorse è possibile posizionare nelle diverse sottocartelle:
  • drawable-*: Queste tre cartelle rispettivamente hdpi, ldpi, mdpi possono contenere immagini di tipo GIF, PNG e JPEG. Da precisare che tutte e tre le cartelle hanno il medesimo ruolo, in quanto Android selezionerà la cartella in base al tipo di display del dispositivo.
  • values/: in questa cartella invece vanno inserite le risorse XML che definiscono variabili e valori che possono essere stringhe, interi e tante altre tipologie di dati. Il codice XML contenuto nel file strings.xml:
    <?xml version="1.0" encoding="utf-8"?>
    <resources>
        <string name="hello">Hello World, ExampleActivity!</string>
        <string name="app_name">Example</string>
    </resources>
    
    Sono definite semplicemente due stringhe, la prima (hello) viene visualizzata come messaggio nell'applicazione, mentre la seconda app_name, rappresenta il nome dell'applicazione che viene visualizzata accanto all'icona. Successivamento vedremo come accedere a queste definizioni.
  • layout/: contiene documenti XML che definiscono i componenti GUI che vengono utilizzati nell'applicazione. I componenti possono essere sia un layout tipo TableLayout, LinearLayout etc. oppure controlli grafici come Button, EditText etc.. Ecco il documento main.xml del progetto che abbiamo creato:
    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:orientation="vertical"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        >
    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/hello"
        android:id="@+id/TextView01"
        />
    </LinearLayout>
    
    In poche parole è stato definito un layout che contiene una TextView che visualizza la stringa 'Hello World, ExampleActivity!'. La definizione della GUI è un aspetto molto importante che può essere facilitato utilizzando l'editor del plugin ADT che genera l'XML in automatico ma non solo. La GUI può essere definita anche direttamente nel codice senza ricorrere all'XML.
Riassumendo: da una parte abbiamo delle risorse XML che definiscono alcune parti dell'applicazione come la GUI oppure dei parametri e valori, mentre dall'altra abbiamo il codice java all'interno di un Activity che deve utilizzare queste risorse per l'applicazione. Come avviene tutto questo? Il ponte fra questi due tipi i componenti viene gestito dalla classe R contenuta nella cartella gen/ e che viene generata dal plugin ADT in maniera automatica ogni qualvolta aggiungiamo un elemento alla struttura di un documento XML già esistente oppure ne creiamo uno nuovo:

Package Explorer classe R

Diamo un'occhiata al codice di questa classe riguardante il progetto che abbiamo creato:
package com.example;

public final class R {
  public static final class attr {
  }
  public static final class drawable {
    public static final int icon=0x7f020000;
  }
  public static final class id {
    public static final int TextView01=0x7f050000;
  }
  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;
  }
}
Per utilizzare le risorse 'mappate' in questa classe si utilizzano alcuni metodi implementati nella classe Activity. Ad esempio analizziamo il codice del nostro esempio:
@Override
public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main);
}
Il metodo setContentView() setta il layout grafico da visualizzare sullo schermo del dispositivo.Il metodo riceve un intero che deve identificare la risorsa XML dove è definito il layout grafico. Quindi la costante R.layout.main identifica questa risorsa. Un'altro metodo molto importante è findViewById(int n) che in questo caso ricerca l'elemento in base all' ID definito nella risorsa XML tramite questo tag:
<TextView
    ....
    android:id="@+id/TextView01"
    ....
/>
Mostriamo un esempio semplice, modificando il colore del messaggio 'Hello World, ExampleActivity!'. Si può fare direttamente da XML, ma anche nel codice a runtime:
...
TextView txtView = (TextView)findViewById(R.id.TextView01);
txtView.setTextColor(Color.RED);
...
Mentre altre tipologie di file come una basdi dati (Android supporta SqlLite) oppure altri tipi di file ad esempio di testo o altro, devono essere inseriti nella cartella raw/ che non viene creata di default ma spetta a noi aggiungerla.

Assets

Ci sono altri tipi di risorse che non vengono mappate nella classe R che vanno inseriti nella cartella assets/ del progetto, e dove l'accesso a tale risorse avviene in tutt'altro modo. Questo tipo di risorse non vengono ne compilate e ne ottimizzate da Android. In questa cartella si può inserire un qualuqnue tipo di file organizzato in una qualsiasi struttura a directory. Per accedere a queste informazioni si utilizza un meccanismo tramite la classe android.content.res.AssetManager all'interno dell'Activity.

AndroidManifest.xml

Tutte le informazioni che abbiamo specificato nella creazione del progetto vengono memorizzati nel file AndroidManifest.xml. Questo documento viene generato in automatico dal plugin ADT una volta terminata la creazione del progetto. In poche parole questo file descrive al dispositivo l'applicazione che dovrà eseguire, ma non tanto in termini di interfaccia grafica, ma raccogliendo le caratteristiche fondamentali, come il nome, l'icona associata etc.. Questo file di configurazione si posizione nella root della cartella del progetto. Il file di configurazione assume la seguente struttura:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="com.example"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".ExampleActivity"
                  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>
    <uses-sdk android:minSdkVersion="4" />
</manifest>
Come potete notare, sono specificati i parametri essenziali che abbiamo settato nella procedura di creazione. La sintassi @string/app_name oppure @drawable/icon sta ad indicare il percorso dove risiedono i componenti nelle locazioni che abbiamo visto precedentemente. E' possibile inoltre specificare altri parametri usando l'apposita finestra che viene visualizzata quando si seleziona il documento:

Editor AndroidManifest.xml

Scendere nel dettaglio per tutti i parametri che si possono definire richiederebbe approfondire altri concetti come l'implementazione di servizi in background oppure definire le permission per l'accesso ad internet o altre funzionalità del dispositivo per la quale è opportuno definire i permessi. Questo sarà argomento di prossimi articoli dove tratteremo l'implementazione di applicazioni un po più complesse e man mano introdurremo questi argomenti.
Altri link che potrebbero interessarti
  • » Screenshot su un dispositivo Android
  • » Pubblicare applicazioni nell'Android Market
  • » Integrare Google Analytics nelle applicazioni Android
  • » Integrare AdMob nelle applicazioni Android
  • » Guida all'installazione dell'Android SDK
  • » Guida agli Adapter e le ListView in Android
  • » Gestire Thread e GUI nelle applicazioni Android
  • » Applicazioni Android ed il supporto multilingue
  • » Android VideoView e le Youtube Api
  • » Android Linkify e i collegamenti testuali
  • » Android HTML TextView
  • » Android e tecniche multithreading
  • » Android e la gestione dei sensori
  • » Android e l'interfaccia Parcelable

  • 1 Commento per "Struttura di un'applicazione Android"

    Autore: Angelo Luciani

    Complimenti. L'articolo a mio modesto parere è scritto benissimo.

    martedì 27 settembre 2011 ore 13:52

    Lascia un commento

    Nome :
    E-mail :
    Commento :

    Tutti i commenti inseriti devono essere approvati da un amministratore prima di essere visualizzati al pubblico. Si tratta di una misura preventiva contro spam e pubblicità e non è necessario reinviare il commento. Si prega di scrivere commenti in tema. Spam e messaggi promozionali non vengono approvati.