Scaricala da Google Play o direttamente dal tuo cellulare nel Google Store!!!!

https://play.google.com/store/apps/details?id=it.danieleserio.wind_pay&feature=search_result#?t=W251bGwsMSwxLDEsIml0LmRhbmllbGVzZXJpby53aW5kX3BheSJd

Permette di attivare e disattivara la Connessione Dati internet con un tocco senza accedere al menù Impostazioni. Semplice e veloce.

Aggiungilo alla schermata home per averlo sempre a disposizione.

 [get_google_lead_90]

https://play.google.com/store/apps/details?id=it.danieleserio.mobyswitchwidget&feature=search_result#?t=W251bGwsMSwxLDEsIml0LmRhbmllbGVzZXJpby5tb2J5c3dpdGNod2lkZ2V0Il0.

Ho avuto la necessità di sviluppare su Firefox 12, e quindi dopo qualche ora di lavoro, ecco qui pronto “GWT Developer Plugin per Firefox 12″.

[get_google_lead_90]

Il plugin è testato e funzionante su tutte le piattaforme e sistemi operativi sia a 32bit che a 64bit. 

Pronta una nuova applicazione Android molto utile! E’ un widget che si può aggiungere alla schermata Home del proprio Smartphone che permette di visualizzare con un tocco il credito telefonico del vostro operatore WIND!

Da oggi non avrete più bisogno di digitare il numero *123# sulla tastiera del telefono, basta cliccare sull’icona dell’applicazione!!

 Ecco il link per poter scaricare l’app dal google play “Credito Wind”:

https://play.google.com/store/apps/details?id=it.danieleserio&feature=search_result#?t=W251bGwsMSwxLDEsIml0LmRhbmllbGVzZXJpbyJd

[get_google_lead_90]

DEMO:

http://wordpress.site5.net/boldy/

 [get_google_lead_90]

DOWNLOAD:

http://www.danieleserio.it/wp-content/uploads/sorgenti/boldy.zip

Ecco a voi una breve guida per la programmazione di Android che ho scritto in questo periodo. La guida ha lo scopo di mostrare i concetti principali e le basi per avvicinarsi al mondo android e per scrivere la vostra prima app.

[get_google_lead_90]

La guida è scaricabile a questo indirizzo in formato PDF:

Per fare un esempio sarà possibile settare una stringa mioNome per la chiave Nome. In un secondo momento, sarà possibile recuperare il valore associato alla chiave Nome semplicemente cercandola all’interno delle Shared Preferences.

Questo tipo di metodologia di immagazzinamento dei dati in maniera permanente, risulta una via di mezzo tra i semplici file di testo e i più complessi database. La considerazione fatta per quanto riguarda la dimensione del set di dati da trattare è identica a quella fatta per i file di testo: anche in questo caso, nel caso in cui ci trovassimo a dover maneggiare set di dati molto grandi, le Shared Preferences non risultano essere la scelta migliore.

Un esempio tipico che ne viene fatto all’interno delle applicazioni è il salvataggio di preferenze da parte dell’utente come, per esempio, la lingua utilizzato oppure le preferenze relative all’audio.

Mostriamo adesso un esempio di utilizzo delle Shared Preferences in una applicazione di esempio. Nel nostro codice andremo a modificare il contenuto di una TextView a seconda che sia stato salvato o meno un certo dato. Il codice di esempio è il seguente:

import android.widget.*;

import android.content.*;

public class provaSharedPreferences extends Activity {            

  private LinearLayout layout;

  private TextView tv;

  /** Called when the activity is first created. */

  @Override

  public void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);   

    Button bottone = new Button(this); 

    layout = new LinearLayout(this);

    layout.addView(bottone);

    layout.addView(tv);

    setContentView(layout);

    SharedPreferences settings = getSharedPreferences(“PROVA”, 0);

    String nome = settings.getString(“nome”, “Nessun valore inserito”);

    tv.setText(“risultato:”+ nome);

    bottone.setOnClickListener(new View.OnClickListener() {

      public void onClick(View view) {

        SharedPreferences settings = getSharedPreferences(“PROVA”, 0);

        SharedPreferences.Editor editor = settings.edit();

        editor.putString(“nome”,”Matteo” );

        editor.commit();

        String nome = settings.getString(“nome”, “Nessun valore inserito”);

        tv.setText(“risultato:”+ nome);

      }

    });

  }

}

Andiamo adesso ad effettuare la consueta analisi del codice. Dopo aver dichiarato e creato widget e layout, vediamo che viene dichiarato un oggetto di tipo SharedPreferences che viene inizializzato utilizzano il metodo getSharedPreferences. Quest’ultimo ritorna la Shared Preference indicata come primo parametro se quest’ultima esiste, altrimenti la crea e ritorna proprio questa shared perference appena creata.

In seguito andiamo a recuperare il valore associato alla chiave nome utilizzando il metodo getString. Quest’ultimo ritorna il valore associato alla chiave indicata come primo parametro se la chiave esiste, in caso contrario ritorna il valore passatogli come secondo parametro.

All’interno del listener associato al bottone andiamo nuovamente a recuperare l’istanza delle Shared Preferences voluta ed andiamo a creare un oggetto di tipo editor necessario per poter modificare i valori all’interno della Shared Preference per il quale è stato creato (ciò avviene con settings.edit()).

L’aggiornamento del valore per la chiave nome viene eseguita invocando il metodo putString sull’oggetto editor precedentemente creato. Come ultima cosa si rendono permanenti le modifiche appena apportate invocando il metodo commit e poi andiamo ad inserire all’interno della TextView il nuovo valore per la chiave key

Questo tipo di problema diviene palese soprattutto qualora vi sia la necessità di effettuare ricerche all’interno dei dati salvati. Pensiamo infatti di voler trovare una certa parola in un file di testo contenente un set di dati molto grande e la parola cercata sia collocata nella parte finale del file. Ovviamente la ricerca richiederebbe diverso tempo in quanto sarebbe necessario scorrere l’intero file.

In queste situazioni è necessario utilizzare un database che migliori nettamente le prestazioni per quanto riguarda le operazioni che comunemente possono essere eseguite su un set di dati, come per esempio la ricerca, l’aggiornamento di un dato e la cancellazione.

Android ci mette a disposizione un database SQLite utilizzabile dalla nostra applicazione. Il linguaggio da utilizzare per compiere qualsiasi operazione sul database è ovviamente l’SQL. Se il lettore ha intenzione di sviluppare un’applicazione che utilizzi un database è opportuno che si documenti a fondo sul linguaggio SQL in generale e in particolare sule metodologie da adottare per ottimizzare le tabelle. Infatti un database non ottimizzato che possiede dei gravi errori concettuali può vanificare il vantaggio di avere un database, in quanto le prestazioni (calcolate sul tempo di esecuzione), per le varie operazioni base, calano vertiginosamente.

Dato che la progettazione di database ottimizzati e privi di errori concettuali esula dallo scopo di questa guida, in questa lazione forniremo al lettore solo le linee guide per utilizzare un database SQLite all’interno di un’applicazione (per approfondimenti sul linguaggio SQL rimandiamo all’apposita sezione su questo sito).

Iniziamo con il dire che ogni database che il programmatore crea è accessibile da qualsiasi classe facente parte dell’applicazione, ma non è visibile all’esterno dell’applicazione stessa.

Esistono diversi modi per creare un database, ma quello che risulta migliore è quello che mostreremo tra poco. Si tratta sostanzialmente di estendere la classe SQLiteOpenHelper e poi effettuare un overriding del metodo onCreate per poter creare le tabelle che sostanzialmente rappresenteranno la struttura del nostro database. Un esempio è mostrato nel codice seguente:

public class MioDatabase extends SQLiteOpenHelper {

  private static final int VERSIONE_DATABASE = 2;

  private static final int NOME_DATABASE = “Prova”;

  private static final String STRINGA_CREAZIONE_TABELLA = “CREATE TABLE prova (” nome TEXT primary key, cognome TEXT);”;

  MioDatabase(Context context) {

    super(context, NOME_DATABASE, null, VERSIONE_DATABASE);

  }

  @Override

  public void onCreate(SQLiteDatabase db) {

    db.execSQL(STRINGA_CREAZIONE_TABELLA);

  }

}

Come possiamo vedere vengono dichiarate tre costanti: una per la versione del database, una per il nome del database e una contente la query per la creazione di una tabella. Fatto ciò definiamo il costruttore della nostra classe, nella quale semplicemente andiamo a richiamare il metodo super (al quale vengono passati alcuni parametri) che richiamerà automaticamete il costruttore della classe SQLiteOpenHelper che abbiamo ereditato andando così a creare il databanse.

Infine nel metodo onCreate creiamo la nostra tabella invocando il metodo execSQL passandogli come attributo la stringa relativa alla creazione della tabella stessa.

Lasciamo a lettore – ed eventualmente a futuri articoli – il compito di approfondire l’argomento relativo al popolamento, alla modifica ed all’interrogazione del database all’interno di applicazioni Android

Per esempio si potrebbe avere la necessità di salvare delle preferenze immesse dall’utente in maniera permanente e permettere all’applicazione, durante l’avvio, di leggere queste preferenze e di agire di conseguenza. Android mette a disposizione diverse possibilità per il salvataggio dei dati in maniera permanente ed è compito del programmatore utilizzare la modalità più appropriata a seconda delle necessità.

Andiamo adesso a presentare le modalità che Android ci offre.

E’ una modalità estremamente semplice nella quale andiamo a creare un file, tipicamente un file di testo, nel quale possiamo scrive e leggere alcuni dati. Di default questo tipo di salvataggio è un salvataggio privato e ciò implica che il file può essere letto e scritto esclusivamente dall’applicazione che lo ha creato e non è dunque possibile accedervi da un’altra applicazione.
Vediamo adesso, con queste poche righe di codice, un esempio pratico della creazione di un file:

String nomeFile = “file_di_prova”;

String string = “Questo è un file scritto da MrWebMaster!”;

FileOutputStream fos = openFileOutput(nomeFile, Context.MODE_PRIVATE);

fos.write(string.getBytes());

fos.close();

In questo codice semplicemente si dichiarano due variabili string, una per il nome del file e una per il contenuto del file stesso. Si apre poi uno stream per il file, si effettua la scrittura con il metodo write ed infine si chiude lo stream con il metodo close.

Se abbiamo la necessità di modificare la proprietà di default settata per la visibilità del file (che come abbiamo detto garantisce l’accesso alla sola applicazione che ha creato il file), dobbiamo agire sul secondo parametro del metodo openFileOutput. E’ possibile infatti scegliere tra i seguenti valori:

• Context.MODE_WORLD_READABLE: viene consentito l’accesso in lettura a tutte le applicazioni.
• Context.MODE_WORLD_WRITEABLE: viene consentito l’accesso in scrittura a tutte le applicazioni.

Ricapitolando questa modalità di storage è una modalità molto semplice ed intuitiva; molto utilizzata nelle applicazioni data la sua facilità implementativa.

Questo tipo di immagazzinamento dei dati permette il salvataggio di alcuni dati, da parte di un’applicazione, su dischi rimovibili dal dispositivo come per esempio una scheda SD. I file salvati su questo tipo di supporti vengono definiti file world-readable ovvero è concesso a tutti le applicazioni di leggerne il contenuto.

E’ opportuno far notare al lettore la “pericolosità” dell’uso di questa metodologia di storage. Questo perché se si effettua il salvataggio di dati su un External Storage è opportuno controllare che i dati salvati non siano indispensabili per il corretto funzionamento dell’applicazione. Questo perché non si ha nessun controllo su questi dati nel caso in cui l’utente rimuova l’SD, la inserisca in un computer e per errore ne cancelli alcune parti.

Dunque si consiglia l’utilizzo di questa metodologia di storage in maniera parsimoniosa

In questa lezione andremo a vedere come richiamare una seconda activity da quella principale.

Andiamo dunque a creare un nuovo progetto e come prima cosa andiamo a creare una nuova classe java chiamandola SecondaAttivita.java. All’interno di questo file inseriamo il seguente codice:

import android.app.Activity;

import android.os.Bundle;

import android.widget.TextView;

import android.view.LinearLayout;

public class SecondaAttivita extends Activity {

  private TextView tv;  

  @Override

  public void onCreate(Bundle savedInstanceState) {

    LinearLayout linear = new LinearLayout(this);

      tv.setText(“Questa è la seconda activity”);    

      linear.addView(tv);

      setContentView(linear);       

  }

}

Come possiamo vedere anche questa seconda classe, essendo un activity, estenderà proprio la classe Activity.

Andiamo adesso ad editare il codice relativo all’activity principale della classe HelloWorld.java posizionandoci, ovviamente, nel metodo onCreate. Inseriamo dunque queste due semplici linee di codice:

Intent miaIntent = new Intent(this, SecondaAttivita.class);

startActivity(miaIntent);

Nella prima prima linea andiamo a istanziare un oggetto di tipo Intent e il tipo di intent che verrà creato sarà un’intent esplicita. Infatti viene utilizzato un costruttore nel quale dobbiamo specificare l’activity che lancia l’intent (nel nostro caso l’activity in cui ci troviamo e dunque passiamo come valore this) e l’activity a cui è diretta l’Intent.

Il metodo startActivity(miaIntent) è il metodo che si occupa di lanciare una nuova activity. Quest’ultima viene attivata per mezzo dell’intent che abbiamo creato nella riga precedente.

A questo punto se provassimo a lanciare la nostra applicazione continueremo, tuttavia, a vedere la stringa di saluto dell’activity principale invece che la stampa reativa alla seconda activity. Questo perché oltre a strutturare via codice la chiamata all’activity secondaria dobbiamo anche dichiararla all’interno del file AndroidManifest.xml.

Andiamo dunque ad aprire il file AndroidManifest.xml e dopo la dichiarazione dell’activity primaria inseriamo, nel listato XML, le seguenti righe di codice:

<activity android:name=”.SecondaAttivita”>

</activity>

In questo modo abbiamo dichiarato la presenza dell’activity all’interno dell’AndroidManifest e se adesso lanciassimo la nostra applicazione otterremo il risultato sperato.

All’interno del file AndroidManifest, dentro la dichiarazione della nuova activity, è possibile impostare gli Intent Filter desiderati a seconda delle esigenze. In questo modo è possibile modellare il comportamento di ogni singola activity dandole la possibilità di rispondere ad intent con le medesime caratteristiche inserite nell’intent filter.

Nell’esempio precedente abbiamo presentato una seconda activity strutturata in maniera molto elementare. E’ ovviamente possibile creare un nuovo file xml per strutturare un layout della window più complessa per poi passare come argomento al metodo setContentView della seconda activity proprio questo file

Come strutturare una seconda activity all’interno di un’applicazione risulta di ovvia intuizione, infatti sarà sufficiente creare un’altra classe Java che estenda la classe Activity per poi inserire questo nuovo file all’interno del nostro progetto. Quello che però manca al lettore, arrivato al punto di questa guida, è il collegamento che esiste tra due o più activity e il modo di richiamare un’altra activity da quella principale. Andiamo dunque a presentare l’oggetto Intent che permette proprio di richiamare una seconda activity da quella principale.

Un’Intent altro non è che un messaggio contenente un insieme di informazioni che vengono inviate ad un altro oggetto il quale, leggendole, effettua alcune operazione stabilite dal programmatore.

Ma quali sono le proprietà (e quindi le informazioni) che un Intent possiede? Vediamo insieme le più significative:

•             Component name: questa è un’informazione opzionale di un intent. Se settiamo unContent name andiamo a fare una dichiarazione esplicita di quale classe andrà a gestire l’intent stessa. La presenza o meno della presenza di questa informazione sta alla base della classificazione delle intent che vedremo in maniera più approfondita tra poco.

•             Action: altro non è che una stringa che identifica il tipo di operazione che sarà eseguita.

•             Data: con questa informazione si indica l’URI della risorsa che vogliamo elaborare. Per esempio un intent che ha la proprietà Action settata al valore ACTION_CALL (valore con il quale si richiede l’avvio di una chiamata) potrebbe avere come valore per la proprietà Data l’URI relativa al numero di telefono.

•             Category: è una stringa contenente informazione aggiuntive sul tipo di componente che andrà a gestire l’activity.

Come anticipato nel paragrafo precedente è possibile catalogare un intent sulla base del Content name. Infatti nel caso in cui venga specificato un gestore dell’intent si parlerà di Intent esplicita la quale è utilizzata principalmente per richiamare altre activity all’interno dell’applicazione chiamante; viceversa si parla di Intent implicita la quale è utilizzata principalmente per richiamare componenti di altre applicazioni.

Ovviamente il lettore si potrebbe chiedere: come fa il sistema operativo a gestire un’ intent implicita se non viene specificato il gestore dell’intent? Per rispondere a questa domanda è indispensabile introdurre gli Intent Filter.

Quest’ultimi altro non sono che delle direttive che hanno lo scopo di informare il sistema operativo quali intent l’applicazione è in grado di gestire. In questo modo, nel caso in cui il sistema operativo riceva un intent implicita di un certo tipo e quel tipo di intent è gestita da una applicazione, andorid potrebbe delegare proprio questa applicazione alla gestione dell’intent.

Per poter associare un Intent Filter alla nostra applicazione è necessario andare a modificare il file AndroidMAnifest.xml. Andando quindi ad aprire questo file all’interno di eclipse: qui possiamo vedere che dopo la dichiarazione dell’activity NomeACtivity al suo interno troviamo gli IntentFilter. Leggendo la tipologia di Intent che la nostra activity è in grado di gestire troviamo le intent che hanno alla proprietà action il valore android.intent.action.MAIN e alla proprietà category il valore android.intent.category.LAUNCHER.

Quella definizione di Intent Filter è necessaria per poter gestire l’intent che automaticamente viene inviata da android all’avvio dell’applicazione (quando l’utente clicca sull’icona relativa all’applicazione). Se provate, infatti, a togliere dal manifest le righe di codice relative all’Intent Filter vedrete che l’applicazione verrà installata correttamente ma non partirà

Il ContextMenu infatti non viene mostrato all’utente in seguito ad una pressione di un tasto sul dispositivo (come invece lo era per gli IconMenu), ma viene associato ad un determinato widget e viene visualizzato all’utente in seguito ad un click prolungato proprio su quel widget.

Ovviamente, all’interno di un’activity, è possibile creare dei ContextMenu diversi per poi associarli a widget diversi, oppure creare un’unico ContextMenu e associarlo a più widget diverse.

Andiamo adesso a mostrare il codice necessario per creare due diversi ContextMenu per poi associarne uno ad un bottone ed un’altro ad una TextView (prima di inserire il codice è necessario importare il pacchetto android.view.ContextMenu.*):

public void onCreate(Bundle savedInstanceState) {

  super.onCreate(savedInstanceState); 

  LinearLayout mioLayout = new LinearLayout(this);

  Button bottone = new Button(this);

  bottone.setId(1);

  button1.setText(“Bottone associato ad un menù”);

  TextView tv = new TextView(this);

  tv.setText(“Fai un click prolungato per il contextmenu”);

  tv.setId(2);

  mioLayout.addView(bottone);

  mioLayout.addView(tv);

  setContentView(layout);

  registerForContextMenu(bottone);

  registerForContextMenu(tv);

}

public void onCreateContextMenu(ContextMenu contextMenu, View view, ContextMenuInfo menuInfo) {

  if(view.getId() == 1) {

    menu.setHeaderTitle(“ContextMenu del bottone”);

    menu.add(Menu.NONE, 1, 1, “Voce bottone 1″);

    menu.add(Menu.NONE, 2, 2, “Voce bottone 2″);

  }

  else if(view.getId() == 2) {

    menu.setHeaderTitle(“ContextMenu della TextView”);

    menu.add(Menu.NONE, 3, 1, “Voce TextView 1″);

    menu.add(Menu.NONE, 4, 2, “Voce TextView 2″);

  }

}

Facciamo l’analisi del codice proposto. Per quanto riguarda il contenuto del metodo onCreate le uniche linee di codice mai viste sono quelle relative all’invocazione del metodo registerForContextMenu che associa, al widget passato come parametro, un eventuale ContextMenu.

Di maggiore interesse risulta invece il metodo onCreateContextMenu che, di fato, contiene il codice relativo ai ContextMenu che vogliamo creare. Anche in questo caso, per creare un diverso menù per i due widget, abbiamo utilizzato il metodo getId() della view che ha richiamato il metodo onCreateContextMenu (il settaggio dell’id dei due widget viene eseguito nel metodo onCreate utilizzando setId()).

All’interno degli if andiamo ad aggiungere al menu le voci che desideriamo con il solito metodo add ed utilizziamo il metodo setHeaderTitle per impostare un titolo al ContextMenu.

Per poter associare un comportamento specifico alla pressione di uno dei tasti del menù si opera nella stessa maniera vista nel capitolo precedente per gli OptionMenu inserendo però il codice desiderato all’interno del metodo onContextItemSelected(MenuItem item)

Il codice all’interno del metodo onCreate, a questo punto della guida, dovrebbe essere di chiara comprensione per il lettore e dunque ne viene volutamente omessa l’analisi. Concentriamo invece la nostra attenzione su un nuovo metodo che ancora non avevamo visto: il metodo OnCreateOptionMenu(Menu menu).

Questo metodo viene richiamato automaticamente dall’Activity non appena l’utente clicca sul tasto menu del simulatore o del dispositivo fisico. Di default il menu è vuoto ed è dunque necessario ridefinire il metodo sopra presentato per poter visualizzare un menù personalizzato. Come possiamo vedere il metodo restituisce un valore booleano: true avrà l’effetto di notificare all’activity di mostrare il menu, mentre false avrà l’effetto contrario (il menù non verrà visualizzato).

Continuando con l’analisi del codice troviamo il metodo che permette di aggiungere una voce al menù che stiamo creando. Il prototipo di questo metodo è il seguente:

add(int groupId, int itemId, int order, CharSequence title)

• Il parametro groupId è un parametro che indica il gruppo di appartenenza della voce del menu (nel nostro caso abbiamo utilizzato Menu.NONE perché non vogliamo utilizzare nessun gruppo);
• itemId indica l’id che verrà associata alla voce del menù (tornerà utile in fase di identificazione di quale voce del menu l’utente ha cliccato);
• order serve per specificare la posizione della voce del menù all’interno del menù stesso;
• title specifica la stringa di testo che verrà mostrata all’utente.

Come abbiamo detto è possibile sostituire il testo della voce del menù con un’immagine. In questo caso è necessario importare la classe anroid.view.MenuItem e sostituire il codice relativo all’aggiunta di una voce del menù con il seguente:

MenuItem voce1 = menu.add(Menu.NONE, 1, 1, “voce1″);

voce1.setIcon(R.drawable.icon);

Come possiamo vedere è necessario creare un oggetto MenuItem utilizzando il metodo add presentato qualche paragrafo prima e poi invocare il metodo setIcon su questo nuovo oggetto.

E’ possibile, seguendo la tecnica già utilizzata con i bottoni, creare un oggetto di tipo MenuItem, associargli un listener e poi fare l’override del metodo che cattura il click.
In questa guida, tuttavia, presenteremo un altro metodo, più semplice e di più facile implementazione, nel quale utilizzeremo la prima implementazione del menù (quella senza la dichiarazione dell’oggetto MenuItem) ed andremo ad aggiungere il metodo onOptionsItemSelected(MenuItem item) che rappresenta il listener che è necessario utilizzare per i menù. Vediamo adesso il codice da aggiungere:

public boolean onOptionsItemSelected(MenuItem item) {

  int id = item.getItemId();   

  switch (id) {

    case 1:

      textView.setText(“Ho cliccato la voce “+ id + ” del menù”);

      break;

    case 2:

      textView.setText(“Ho cliccato la voce “+ id + ” del menù”);

      break;

  }

}

Per esigenze di spazio abbiamo gestito solo il click sulle prime due voci del menù, si lascia per esercizio al lettore il completamento del case.
Il codice mostrato è molto semplice infatti si memorizza nella variabile id l’identificativo numerico associato alla voce del menù che è stata cliccata. Ciò viene effettuato con la chiamata, sull’oggetto item, del metodo getId().
All’interno di ogni case inseriremo il codice che modella il comportamento dell’applicazione al click della voce del menù che solitamente richiama un’altra activity sostituendola a quella attuale (vedremo più avanti come fare)

Iniziamo con il presentare gli OptionsMenu. Questo tipo di menù è posizionato nella parte bassa dello schermo ed è possibile individuarne due strutture principali: gli icon menu e gliexpanded menu.

Gli Icon Menu solitamente contengono le operazioni più importanti che un utente può eseguire all’interno dell’applicazione. Come detto vengono posizionati nella parte bassa dello schermo e sono visibili all’utente solamente dopo la pressione del tasto menù del dispositivo (ciò vale anche sul simulatore).

Una pratica molto usata è quella di inserire in questo menù delle icone che sintetizzano il risultato dell’operazione che verrà effettuata al click della voce del menù. Se per esempio facciamo riferimento ad un’applicazione per la riproduzione di brani musicali, si potrebbe pensare di associare alla voce del menù play l’icona associata a quella operazione (il tringolino iscritto in un cerchio).

Per quanto riguarda questo menù abbiamo una limitazione sul numero di voci che è possibile inserire e questo numero è pari a sei. Ma cosa succede se inseriamo un numero di voci maggiori di sei? semplicemente la sesta voce del menù verrà mutata in una voce altroche se cliccata aprirà un expanded menu contenente le altre voci. Quest’ultime verranno visualizzate in una lista a tutto schermo che si espanderà dal basso verso l’alto andando progressivamente a coprire il contenuto base della window dell’activity.

Detto ciò è opportuno mostrare un po’ di codice (da inserire all’interno della nostra activity) che andrà a creare un Options menù che sarà formato da Icon menu e da Expanded menù (prima è necessario importare la classe android.view.Menu):

public void onCreate(Bundle savedInstanceState) {

  super.onCreate(savedInstanceState);

  LinearLayout linearLayout = new LinearLayout(this);

  TextView textView = new TextView(this);

  textView.setText(“Clicca sul tasto menù del simulatore”);

  linearLayout.addView(textView);

  setContentView(linearLayout);  

}

public boolean onCreateOptionsMenu(Menu menu) {

  menu.add(Menu.NONE, 1, 1, “Voce 1″);

  menu.add(Menu.NONE, 2, 2, “Voce 2″);

  menu.add(Menu.NONE, 3, 3, “Voce 3″);

  menu.add(Menu.NONE, 4, 4, “Voce 4″);

  menu.add(Menu.NONE, 5, 5, “Voce 5″);

  menu.add(Menu.NONE, 6, 6, “Voce 6″);

  menu.add(Menu.NONE, 7, 7, “Voce 7″);

  menu.add(Menu.NONE, 8, 8, “Voce 8″);

  return true;

}

Come detto precedentemente se clicchiamo sul tasto menu del simulatore renderemo visibile l’icon menu raffigurato nello screenshot seguente:

In accordo con quanto detto, dato che abbiamo inserito un numero di voci superiore a sei, l’ultima voce sarà il punto di accesso all’expanded menu che è possibile vedere in questo screnshot:

Come possiamo vedere una volta cliccato qualunque delle voci del menù, quest’ultimo tornerà invisibile all’utente.

Nel prossimo capitolo analizzeremo il codice presentato ed assoceremo un particolare listener alle voci del menu

In questa lezione andremo ad analzizare il codice relativo all’OptionsMenu che abbiamo creato al la lezione precedente.

Il codice all’interno del metodo onCreate, a questo punto della guida, dovrebbe essere di chiara comprensione per il lettore e dunque ne viene volutamente omessa l’analisi. Concentriamo invece la nostra attenzione su un nuovo metodo che ancora non avevamo visto: il metodo OnCreateOptionMenu(Menu menu).

Questo metodo viene richiamato automaticamente dall’Activity non appena l’utente clicca sul tasto menu del simulatore o del dispositivo fisico. Di default il menu è vuoto ed è dunque necessario ridefinire il metodo sopra presentato per poter visualizzare un menù personalizzato. Come possiamo vedere il metodo restituisce un valore booleano: true avrà l’effetto di notificare all’activity di mostrare il menu, mentre false avrà l’effetto contrario (il menù non verrà visualizzato).

Continuando con l’analisi del codice troviamo il metodo che permette di aggiungere una voce al menù che stiamo creando. Il prototipo di questo metodo è il seguente:

add(int groupId, int itemId, int order, CharSequence title)

• Il parametro groupId è un parametro che indica il gruppo di appartenenza della voce del menu (nel nostro caso abbiamo utilizzato Menu.NONE perché non vogliamo utilizzare nessun gruppo);
• itemId indica l’id che verrà associata alla voce del menù (tornerà utile in fase di identificazione di quale voce del menu l’utente ha cliccato);
• order serve per specificare la posizione della voce del menù all’interno del menù stesso;
• title specifica la stringa di testo che verrà mostrata all’utente.

Come abbiamo detto è possibile sostituire il testo della voce del menù con un’immagine. In questo caso è necessario importare la classe anroid.view.MenuItem e sostituire il codice relativo all’aggiunta di una voce del menù con il seguente:

MenuItem voce1 = menu.add(Menu.NONE, 1, 1, “voce1″);

voce1.setIcon(R.drawable.icon);

Come possiamo vedere è necessario creare un oggetto MenuItem utilizzando il metodo addpresentato qualche paragrafo prima e poi invocare il metodo setIcon su questo nuovo oggetto.

E’ possibile, seguendo la tecnica già utilizzata con i bottoni, creare un oggetto di tipoMenuItem, associargli un listener e poi fare l’override del metodo che cattura il click.
In questa guida, tuttavia, presenteremo un altro metodo, più semplice e di più facile implementazione, nel quale utilizzeremo la prima implementazione del menù (quella senza la dichiarazione dell’oggetto MenuItem) ed andremo ad aggiungere il metodoonOptionsItemSelected(MenuItem item) che rappresenta il listener che è necessario utilizzare per i menù. Vediamo adesso il codice da aggiungere:

public boolean onOptionsItemSelected(MenuItem item) {

  int id = item.getItemId();   

  switch (id) {

    case 1:

      textView.setText(“Ho cliccato la voce “+ id + ” del menù”);

      break;

    case 2:

      textView.setText(“Ho cliccato la voce “+ id + ” del menù”);

      break;

  }

}

Per esigenze di spazio abbiamo gestito solo il click sulle prime due voci del menù, si lascia per esercizio al lettore il completamento del case.
Il codice mostrato è molto semplice infatti si memorizza nella variabile id l’identificativo numerico associato alla voce del menù che è stata cliccata. Ciò viene effettuato con la chiamata, sull’oggetto item, del metodo getId().
All’interno di ogni case inseriremo il codice che modella il comportamento dell’applicazione al click della voce del menù che solitamente richiama un’altra activity sostituendola a quella attuale (vedremo più avanti come fare)

I contenuti all’interno di un TableLayout vengono organizzati grazie ad un oggettoTableRow che identifica una riga della tabella. All’interno di questo oggetto dovremo inserire tutti gli elementi che vogliamo mostrare in quella specifica riga.

Mostriamo adesso un esempio chiarificatore andando a creare un TableLayout con quattro righe e quattro colonne. Il codice Java per crearlo è il seguente (anche in questo caso per comodità importiamo andorid.widget.*):

TableLayout tableLayout = new TableLayout(this);

tableLayout.setGravity(Gravity.TOP);

int count=0;

for (int i = 0; i < 4; i++) {

  TableRow tableRow = new TableRow(this);

  tableRow.setGravity(Gravity.CENTER);

  for (int j = 0; j < 4; j++) {

    count++;

    TextView testoCella = new TextView(this);

    testoCella.setText(“cella “+ count);

    testoCella.setPadding(10, 10, 10, 10);

    tableRow.addView(testoCella);

  }

  tableLayout.addView(tableRow);

}

setContentView(tableLayout);

Andiamo adesso a fare un’analisi rigorosa del codice. Come prima cosa viene creato un oggetto di tipo TableLayout che viene posizionato nella parte alta dello schermo. La costruzione del layout vera e propria viene eseguita per mezzo di due for annidati.
Nel primo for dichiariamo un oggetto di tipo tableRow e settiamo la proprietà gravity per centrare il contenuto all’interno dell’oggetto.
Ad ogni iterazione del secondo for andiamo a riempire la tableRow con una TextView(utilizziamo la variabile count incrementata ad ogni iterazione), poi applichiamo un padding di 10 pixel dai quattro bordi della cella ed infine associamo la TextView alla TableRow creata nel for primario.
Al termine del primo for aggiungiamo la TableRow (contenente tutte e quattro le nostre TextView create col ciclo annidato) al TableLayout. Infine, con il solito comando setContentView, andiamo ad associare il TableLayout creato alla window della nostra activity

Il risultato finale è mostrato nello screenshot di seguito:

Oltre ai due Layout visti precedentemente ne esistono altri due di più semplice utilizzo: FrameLayout e RelativeLayout. Il primo è un layout elementare infatti può contenere un solo widget e lo estende per tutta la grandezza disponibile partendo dal punto in alto a sinistra dello schermo. Il secondo invece posizione l’elemento nella window con le sue dimensioni originali e dunque senza effettuare nessun ridimensionamento.

Ovviamente, in una window, è possibile utilizzare contemporaneamente più tipi di layout, ricordandoci però di inglobarli poi in un unico layout che verrà passato come argomento al metodo setContentView. Un esempio di quanto detto è mostrato nel codice seguente:

LinearLayout linearLayout1 = new LinearLayout(this);

//Codice relativo all’inserimento di elementi per questo layout

TableLayout tableLayout = new TableLayout(this);

//Codice relativo all’inserimento di elementi per questo layout

LinearLayout linearLayoutPrimario = new LinearLayout(this);

linearLayoutPrimario.setOrientation(LinearLayout.VERTICAL);

linearLayoutPrimario.addView(linearLayout1);

linearLayoutPrimario.addView(tableLayout);

setContentView(linearLayoutPrimario);

E’ uno tra i layout più utilizzati in quasi tutte le applicazioni Android. La particolarità di questo layout, come abbiamo visto, è quello di disporre gli elementi inseriti nella window dell’activity uno di seguito all’altro.

A seconda del valore dell’orientazione del LinearLayout si parla di LinearLayout verticale (gli elementi vengono disposti uno dopo l’altro dall’alto verso il basso) e LinearLayout orizzontale (gli elementi vengono disposti uno dopo l’altro da sinistra verso destra). Per poter settare l’orientamento del layout è sufficiente, nel file .xml utilizzato, editare la seguente proprietà con il valore vertical o horizontal:

android:orientation=”"

Come detto i componenti aggiunti al layout vengono disposti su una linea verticale o orizzontale a seconda dell’orientamento dato al layout. Questi elementi vengono aggiunti alla window finche c’è spazio e non appena si richiede l’inserimento di un ulteriore elemento, android cerca di ridimensionarlo per inserirlo comunque all’interno dello schermo. Questo comportamento è limitato ad una soglia dopo la quale, semplicemente, gli elementi aggiunti non vengano visualizzati sullo schermo.

Si sconsiglia al lettore di non inserire mai elementi in eccesso nella window in quanto il ridimensionamento automatico fatto da Android spesso deforma i componenti inseriti rendendo l’interfaccia grafica poco gradevole se non, addirittura, poco usabile. Inoltre gli elementi che Android, per mancanza di spazio, non mostra a schermo risiedono comunque in memoria andando a sprecare dello spazio prezioso.

Per mostrare un esempio di quanto detto, andiamo a costruire un LinearLayout orizzontale con tre bottoni, a cui poi ne aggiungeremo un quarto per mostrare il ridimensionamento e l’interfaccia grafica che ne scaturisce. A differenza di quanto visto finora, creeremo l’interfaccia grafica direttamente da codice Java senza appoggiarsi ad un file esterno .xml. Ciò viene mostrato al lettore per presentare questo diverso modo di operare (per comodità importiamo direttamente android.widget.*):

LinearLayout layout = new LinearLayout(this);

layout.setOrientation(LinearLayout.HORIZONTAL);

layout.setGravity(Gravity.BOTTOM);

Button button1 = new Button (this);

button1.setText(“Bottone 1″);

Button button2 = new Button (this);

button2.setText(“Bottone 2″);

Button button3 = new Button (this);

button3.setText(“Bottone 3″);

layout.addView(button1);

layout.addView(button2);

layout.addView(button3);

setContentView(layout);

Come prima cosa dichiariamo un oggetto di tipo LinearLayout, poi settiamo l’orientamento orizzontale del layout ed infine settiamo la posizione (in basso dello schermo) dove andremo a posizionare i nostri oggetti. Dichiariamo poi tre bottoni, li associamo al layout con addView ed infine utilizziamo il metodo setContentView per associare il layout alla window dell’activity.

Andiamo adesso ad inserire un quarto bottone (si lascia per esercizio al lettore la scrittura del codice) al layout e come possiamo vedere dallo screenshot seguente il ridimensionamento sforma il bottone mostrando un’interfaccia non molto professionale:

Per l’aggiunta dei bottoni nella ALertDialog e dell’associazione dei listener è sufficiente sostituire il codice scritto nel capitolo precedente con il seguente:

AlertDialog.Builder miaAlert = new AlertDialog.Builder(this);

miaAlert.setMessage(“Verifichiamo il funzionamento dei bottoni aggiunti!”);

miaAlert.setTitle(“AlertDialog di MrWebMaster”);

miaAlert.setCancelable(false);

miaAlert.setPositiveButton(“Si”, new DialogInterface.OnClickListener() {

  public void onClick(DialogInterface dialog, int id) {

    tv.setText(“Ho cliccato il tasto SI”);

  }

});

miaAlert.setNegativeButton(“No”, new DialogInterface.OnClickListener() {

  public void onClick(DialogInterface dialog, int id) {

    tv.setText(“Ho cliccato il tasto NO”);                              

  }

});

AlertDialog alert = miaAlert.create();

alert.show();

Per quanto riguarda la prime tre righe di codice non è necessario spiegare niente in quanto sono identiche a quelle mostrate nel capitolo precedente. Andando avanti con l’analisi del codice troviamo l’invocazione del metodo setCanceble(false) che ha l’effetto di disabilitare il tasto back del telefono e dunque l’utente dovrà necessariamente cliccare su uno dei due bottoni per chiudere l’AlertDialog.

Detto questo passiamo alla creazione dei bottoni veri e propri. Il primo bottone viene creato con il metodo setPositiveButton il quale prende in ingresso una stringa che verrà mostrata a schermo come contenuto del bottone e un listener. Come possiamo vedere il listener viene dichiarato come nuova istanza di DialogInterface.OnClickListener e non come nuova istanza di View.OnClickListener. Quest’ultimo infatti può essere applicato solamente ad elementi che eriditano la classe View e dato che le AlertDialog non ereditano questa classe, ma fanno parte del package android.app, è necessario utilizzare un listener di tipo DialogInterface.

All’atto pratico questa differenza non è sostanziale, infatti, anche in questo caso, sarà necessario ridefinire il metodo OnClick ed inserirvi il codice relativo al comportamento che vogliamo dare ai due bottoni. Come possiamo vedere il metodo OnClick prende in ingresso due parametri: il primo è un oggetto di tipo AlertDialog (che ci indica quale dialog ha generato l’attivazione del listener) e poi un id che identifica il bottone premuto. All’interno del metodo OnClick semplicemente andiamo a cambiare il testo relativo alla TextView tv.

La struttura del metodo OnClick ci suggerisce una versione ottimizzata del nostro listener. Infatti sapendo quale AlertDialog ha attivato il listener e quale bottone all’interno della alert è stata cliccato sarà possibile creare un un’unico listener per gestire più AlertDialog ed i relativi bottoni. Ciò si realizza semplicemente eseguendo un primo switch sull’attributo Dialog (andiamo ad identificare quale AlertDialog ha attivato il listener) ed in ogni case relativo alle AlertDialog inserire all’interno un altro switch per capire quale bottone, relativo alla AlertDialog presa in esame, è stato cliccato.

Si lascia per esercizio al lettore questa nuova implementazione del listener che sostanzialmente è molto simile a quella vista nei capitoli precedenti di questa guida

Per esempio un’applicazione che richiede una connessione ad Internet per compiere alcune operazioni, potrebbe mostrare un’AlertDialog all’utente nel caso in cui il dispositivo non si riesca a collegare ad una rete Wi-Fi.

Bisogna precisare che l’AlertDialog, una volta mostrata a schermo, renderà l’activity che l’ha generata priva di interazione con l’utente. Si potrà nuovamente interagire con l’activity solo ed esclusivamente quando si deciderà di chiudere l’AlertDialog.

Vediamo adesso come costruire una AlertDialog personalizzata nel titolo e nel messaggio ed avente due bottoni ai quali verrà associato un listener che sarà in grado di capire quali dei due bottoni è stato cliccato.

Per prima cosa vediamo il codice relativo alla creazione di una ALertDialog. Per far ciò possiamo tranquillamente posizionarci in un file .java (se utilizziamo il vecchio progetto posizioniamoci nel file HelloWorld.java) e come prima cosa importiamo i seguenti pacchetti:

import android.app.AlertDialog;

import android.content.DialogInterface;

Il primo pacchetto importerà la classe relativa all’AlertDialog ed il secondo pacchetto importerà gli strumenti necessari per poter applicare un listener ai bottoni che aggiungeremo alla AlertDialog.

Importati gli strumenti necessari inseriamo il seguente codice all’interno del metodoOnCreate ed ovviamente dopo l’invocazione del setContentView:

AlertDialog.Builder miaAlert = new AlertDialog.Builder(this);

miaAlert.setTitle(“AlertDialog di MrWebMaster”);

miaAlert.setMessage(“Questa è la mia prima AlertDialog”);

AlertDialog alert = miaAlert.create();

alert.show();

Analizzando il codice vediamo che la creazione dell’intera struttura della alert viene affidata all’oggetto AlertDialog.Builder che, attraverso l’invocazione dei metodo setTitle e setMessage imposta il titolo ed il messaggio della AlertDialog da mostrare all’utente. Da notare che al costruttore dell’oggetto AlertDialog.Builder viene passato come contesto this ovvero l’activity con cui stiamo lavorando in questo momento.

Strutturata l’AlertDialog viene creato un oggetto AlertDialog inizializzandolo con le caratteristiche impostate dal builder attraverso il metodo onCreate. Fino a questo momento abbiamo solamente instanziato l’oggetto AlertDialog e se lanciassimo l’applicazione non la vedremo apparire sullo schermo. Per ovviare a ciò si invoca il metodo show che appunto permette la visualizzazione a schermo dell’AlertDialog.

Una pratica molto comune è quella di aggiungere, prima del titolo dell’AlertDialog un’immagine esplicativa che dovrebbe raffigurare il significato del messaggio. Per intenderci se il messaggio mostrato all’utente è un messaggio d’errore sarebbe opportuno inserire un’immagine che per esempio rappresenti un punto esclamativo su sfondo rosso oppure, se il messaggio è un messaggio di warning associare la classica immagine di un punto esclamativo inscritto in un triangolo giallo.

Per mostrare come compiere questa ulteriore personalizzazione utilizzeremo l’immagineicon.png (quella che identifica la nostra applicazione nel menù) localizzata dentro la cartella res/drawable.

E’ sufficiente inserire nel builder questa ulteriore riga di codice:

miaAlert.setIcon(R.drawable.icon);

Nel prossimo capitolo andremo ad aggiungere i bottoni alla AlertDialog e assoceremo i listener

Un esempio di utilizzo di questo widget è quello per notificare all’utente un messaggio del tipo “salvataggio effettuato” oppure “operazione eseguita” in seguito a qualche operazione compiuta dall’utente. La caratteristica di questo widget è quello di essere estremamente semplice in quanto ha la possibilità di mostrare a video solamente un messaggio o un’immagine senza però poter interagire con l’utente.

Vediamo adesso il codice necessario per mostrare a video un toast con un testo da noi personalizzato. Per far ciò possiamo riprendere un vecchio progetto relativo ai bottoni e i listener oppure (operazione consigliata per prendere familiarità con la programmazione) riscrivere il codice relativo ad un bottone e all’associazione ad esso di un OnClickListener. Per poter utilizzare i Toast è necessario importare nel nostro progetto la classe:

android.widget.Toast

Posizioniamoci adesso all’interno del metodo OnClick ed inseriamo queste due linee di codice:

Toast mioToast = Toast.makeText(HelloWorld.this,

“Questo è un Toast creato da MrWebMaster”,

Toast.LENGTH_LONG);

mioToast.show();

Andiamo ad analizzare con attenzione il metodo makeText ed il prototipo del metodo che è il seguente:

makeText(Context context, CharSequence text, int duration)

Come primo parametro, il metodo richiede il contesto nel quale applicare il toast. Dato che il codice è inserito all’interno del listener non possiamo passare come contesto this in quanto passeremo come argomento il listener stesso al quale non è applicabile un toast. E’ necessario passare come contesto l’activity principale per poter mostrare il toast a video e dunque inseriremo come parametro HelloWorld.this.
Come secondo parametro, banalmente, viene passato un testo che vogliamo mostrare all’utente.
Infine come ultimo parametro, viene passata una costante, nel nostro caso LENGHT_LONG, che serve a specificare la durata di visibilità del Toast. Purtroppo non è possibile specificare, in questo parametro, i secondi precisi duranti i quali il Toast deve essere visibile, ma bensì è possibile scegliere solamente tra la costante vista prima e la costante LENGHT_SHORT che setta una durata della visibilità del Toast minore rispetto alla prima costante.

Ricapitolando, l’effetto della prima porzione di codice è quello di istanziare un oggetto di tipo Toast con le caratteristiche volute; ancora, però, il Toast non è visibile. Per far ciò è necessario invocare il metodo show() sul Toast stesso.

Come possiamo vedere, nel primo esempio mostrato, non abbiamo indicato alla nostra activity dove posizionare il nostro Toast. Per utilizzare il metodo per settare la posizione del toast è necessario prima importare la seguente classe:

android.view.Gravity

Per posizionare il Toast, per esempio, al centro della schermata basta inserire questa linea di codice prima dell’invocazione del metodo show():

setGravity(Gravity.CENTER, 0, 0);

Come possiamo vedere passiamo come primo argomento il centro dello schermo e poi viene indicato lo scostamento sull’asse x e sull’asse y dal punto precedentemente indicato.

E’ possibile, come già detto, sostituire il testo del toast con un’immagine da mostrare all’utente. In questo caso, ovviamente, non sarà possibile utilizzare il metodo makeText, ma dovremo utilizzare il costruttore Toast(Context context) passando solo il contesto (quello relativo all’activity). In seguito dovremo utilizzare il metodo setView() per associare l’immagine al nostro Toast.
Di seguito il codice completo per mostrare un’immagine mediante Toast:

ImageView imageForToast = new ImageView(HelloWorld.this);

imageForToast.setImageResource(R.drawable.icon);

Toast mioToast = new Toast(HelloWorld.this);

mioToast.setView(imageForToast);

mioToast.show();

Andando ad esplorare proprio questa cartella troveremo una sottocartella layout, che abbiamo utilizzato abbondantemente fino a questo momento, ed altre tre sotto cartelle identificate dai seguenti nomi:

• drawable-hdpi
• drawable-mdpi
• drawable-ldpi

Le sottocartelle sopra elencate sono quelle che dovranno contenere le immagini che desideriamo inserire all’interno della nostra applicazione.

Ma quale è il significato di queste cartelle? Dunque dato che Android è un sistema operativo mobile che è installato su dispositivi diversi aventi risoluzione diversa, per avere una sorta di ottimizzazione dell’immagine è opportuno creare tre versioni delle immagini a grandezze differenti. Queste tre versioni delle immagini dovranno essere inserite in ordine di grandezza dalla più grande alla più piccola nelle cartelle viste sopra.

Ovviamente per visualizzare un’immagine a schermo è sufficiente che ci sia almeno una versione dell’immagine all’interno di una delle tre cartelle. Nel caso in cui volessimo mostrare un’immagine ottimizzata per schermi a bassa risoluzione su schermi ad alta risoluzione dovremo necessariamente ingrandire l’immagine causando un inevitabile sfuocamento dell’immagine stessa.

Detto ciò forniamo un esempio pratico. Prendiamo un’immagine di esempio e inseriamola nelle cartelle viste sopra (anche evitando di creare tre versioni dell’immagine). Fatto ciò è necessario aprire il file main.xml ed inseriamo il codice relativo alla dichiarazione della nostra ImageView che abbiamo chiamato Image:

<ImageView android:id=”@+id/Image”

android:layout_width=”wrap_content”

android:layout_height=”wrap_content”>

</ImageView>

Apriamo adesso il file .java ed importiamo l’oggetto ImageView

android.widget.ImageView

dichiariamo un oggetto di tipo ImageView

private ImageView miaImmagine;

ed infine inseriamo il seguente codice:

miaImmagine = (ImageView) findViewById(R.id.Image);

miaImmagine.setImageResource(R.drawable.ImmagineEsempio);

Come possiamo vedere il codice relativo alla visualizzazione di un’immagine è molto semplice. Nella prima riga associamo l’elemento dichiarato nell’XML con quello dichiarato nel codice e inseguito impostiamo il valore dell’immagine con il metodo setImageResource. Passiamo a questo metodo il codice relativo alla nostra immagine che troviamo nel file R sella sotto-classe drawable.

Come è intuibile capire, quando inseriamo una qualsiasi immagine all’interno di una delle cartelle drawable-… automaticamente verrà creata una costante relativa all’immagine nel file R nella sotto-classe drawable. Il nome usato nell’esempio, ImmagineEsempio, è il nome relativo al file che identifica l’immagine. Come possiamo vedere è sufficiente inserire solamente il nome del file omettendo l’estensione.

Una particolarità di android è quella di effettuare un resize automatico dell’immagine di dimensioni superiori alla risoluzione dello schermo. Per vedere questo comportamento è sufficiente mostrare a schermo un immagine ad alta risoluzione. Quest’ultima verrà ridimensionata, in maniera del tutto automatica, e adattata allo schermo del simulatore o del dispositivo senza problemi. Il resize di un’immagine da più grande a più piccola non comporta nessuna perdita di qualità (si aumentano però le operazioni che vengono eseguite dal sistema operativo quando viene lanciata l’applicazione) viceversa, come abbiamo detto precedentemente, si avrebbe una perdita di qualità proporzionale all’ingrandimento.