[DEV] Gestione dei menù

Pubblicato da Fabrizio Russo il giu 23, 2010 in News, Sviluppo | 4 commenti

Tweet

Android definisce due tipologie di menu, visualizzabili a seconda delle circostanze in cui si sta operando. Quando un’Activity è visualizzata (stato RUNNING) e viene premuto il tasto Menu (Android definisce un tasto fisico apposta per i menu) viene eseguito una tipologia di menu chiamata “Option”, mentre se si ha il  focus su una View (tipicamente una casella di testo) e si preme a lungo sullo schermo può essere visualizzato un menù contestuale relativo al componente.

Option Menu

I menu Option vengono visualizzati alla pressione del tasto menu e sono relativi all’Activity in quel momento visualizzata. Ad ogni activy è associabile un solo optio menu anche se è possibile renderlo dinamico in modo da adattarsi a diverse situazioni.

Ad ogni menu è possibile associare diversi parametri (che vedremo in dettaglio successivamente) ma in generale è possibile associare un testo ed una icona. Vista la dimensione ridotta dei dispositivi i menu di questo tipo hanno due modalità di visualizzazione : icona e espanso. La logica di visualizzazione è la seguente:

1. Se per una data activity sono definiti meno di sette menù (cioè meno di sei o esattamente sei) per ogni menu si ha la possibilità di visualizzare sia l’icona che il testo (ovviamente l’icona ed il testo devono essere definiti e l’ordine di visualizzazione è importante)
2. Se per l’Activity ci sono più di 6 menu, allora per i primi cinque viene visualizzata l’icona ed il testo, il sesto menù diventa un menù di accesso gestito dal sistema (il classico menù “altro”) alla pressione del quale compare una lista scorrevole di menù dove viene riportato il solo testo (non l’icona) dei restanti items

Per un esempio, del primo tipo, aprite l’applicazione GMail e premete il tasto Menu. Verranno visualizzati sei menù ognuno dei quali ha una icona ed un testo. Questo caso ricade nel primo tipo in quanto i menù sono esattamente sei e non c’è la necessità di visualizzare il tasto “Altro”. (notare inoltre lo stile dell’icona, che non è colorata ed è stilizzata)

Per un esempio del secondo tipo, aprite il calendario ed accedete al menù. Verranno visualizzati cinque menù ed il menù altro, alla pressione del quale compare una lista di menu (in questo caso composto da altri due item). Anche qui notate lo stile delle icone, ne riparleremo dopo.

Oltre a questa differenza è importante notare che i menù visualizzati per prima (nei primi 6) ed i menù visualizzati per secondi (dopo aver premuto il tasto “more”) hanno caratteristiche diverse oltre all’icona.

Infatti ad ogni menù è possibile associare una check di selezione. Si pensi ad esempio ad un menù che deve semplicemente abilitare o disabilitare una opzione senza mostrare altri dati. I menù “checkabili” possono oerò solo essere quelli visualizzati nell’elenco dei menù successivi ai primi sei e non possono avere quindi un’icona.

Ovviamente ogni item di menu (dal punto di vista java) è sempre un oggetto della classe MenuItem e di conseguenza sia se abbia un’icona o una voce selezionabile è gestita dal sistema. Nel senso che se ad una item di menù tra i primi sei gli si associa un item selezionabile oppure ad un item di menù successivo gli si associa una icona il sistema ignora queste configurazioni.

Context Menu

I context Menu sono invece dei menù a scomparsa che appaiono alla pressione prolungata su di una View. Sono di contesto perché chiaramente dipendono dall’ item a cui appartengono. Ad esempio, su una voce di testo (TextView) un menù di contesto potrebbe contenere voci quali copia, incolla, invia x sms, … mentre su di una immagine (ImageView) potrebbe avere voci tipo taglia, ruota, ecc ecc

Gestione Java e ciclo di vita

Vediamo ora come si definiscono i menu in Android. Partendo dall’ Option menù e dai metodi che la classe Activity mette a disposizione per la loro gestione. Il primo metodo messo a disposizione è

    public boolean onCreateOptionsMenu(Menu menu)

che viene innvocato SOLO alla prima pressione del tasto Menu. L’oggetto passato come parametro è il menù al quale dovremo aggiungere le varie voci di menu che si intendono visualizzare.

E’ importante sottolineare che questo metodo viene invocato SOLO una volta, cioè alla seconda pressione del tasto Menù, non viene invocato e viene visualizzato il menù costrutito precedentemente. Questo perchè il significato che Android da al menù costruito con questo metodo è di menù statico.

Per menù statico si intende quindi un menù che non cambia tra una chiamata e l’altra.

Se si intende modificare lo stato del menù (o creare un menù dinamicamente ad ogni pressione del tasto Menù) allora bisogna implementare il metodo

     public boolean onPrepareOptionMenu(Menu menu)

Il parametro passato come argomento è il menù creato precedentemente (o un menù vuoto se è la prima pressione del tasto Menù).

Nota: Se si intende creare ogni volta il menù ex-novo è importante allora chiamare il metodo clear() altrimenti i menù saranno duplicati, triplicati, ecc ecc ad ogni invocazione del metodo.

android.view.Menu

La classe Menu offre diversi metodi per creare ed aggiungere Menu, molti dei quali implementano il pattern builder dando quindi la possibilità di invocarli in cascata ( metodo1().metodo2().metodo3() )

la classe Menu offre molti metodi ma i principali sono:

    addSubMenu(groupID, menuID, order, stringID)

dove:

• groupID : Intero che identifica un gruppo di appartenza della voce di menù. Questo ID serve nel caso si vogliano effettuare operazioni di gruppo sui menù (tipo disabilitare tutte le voci di menù appartenenti ad un gruppo)
• menuID: Intero che rappresenta l’identificativo della voce di menù. Questo ID è importante perchè serve a capire successivamente quale voce di menù è stata selezionata.
• order: Ordine di visualizzazione del menù (la posizione)
• stringID : Riferimento alla stringa da visualizzare nel menù

Altro metodo importante è

    setIcon( iconID )

dove iconID è l’identificativo di un oggetto Drawable che rappresenta l’icona del menù

Qui è importante fare una osservazione. Sebbene si è liberi di scegliere l’icona che più ci piace per le nostre voci di menù, è bene seguire delle regole di disegno dettate dalla piattaforma Android. Queste regole sono consultabili all’indirizzo

http://developer.android.com/guide/practices/ui_guidelines/icon_design.html

dove, olre alle regole per le icone dei menù ci sono anche le regole per le icone delle applicazioni e delle liste.

E’ possibile utilizzare anche icone predefinite messe a disposizione da Android stesso (le famose icone grigie di cui si è parlato in precedenza). Tutte queste icone si trovano all’interno del file android.jar dell’ SDK che state utilizzando. Una visualizzazione web è consultabile ad esempio all’indirizzo

http://www.darshancomputing.com/android/1.5-drawables.html

Metodi di callback

Quando una voce di menù viene selezionata, viene invocato nell’activity il metodo

 public boolean onOptionItemSelected(MenuItem item)

dal quale, attraverso il metodo getItemID dell’oggetto item è possibile effettuare uno switch su quale voce di menù è stata selezionata (paremetro menuID passato in fase di creazione).

Chiaramente cosa faccia un menù dipende dal significato che gli si vuol dare, in genere viene lanciata una nuova activity per effettuare qualche tipo di operazione.
Context Menù

I menù contestuali invece sono legati ad una view e quindi per essere visualizzati, l’activity deve quindi sapere quali View al suo interno hanno la possibilità di visualizzare contextMenù. Quindi bisogna registrare, attraverso il metodo

 registerForContextMenu(View v)

tutte le View a cui si intende associare un contextMenù. (Questo normalmente si fa nel metodo onCreate)

Successivamente, per tutti i compenti registrati, quando viene esercitata un pressione sulla view, viene invocato il metodo dell’activity

 public void onCreateContextMenu(ContextMenu menu, View  view, ContextMenuInfo menuInfo)

dell’activity dove il parametro v rappresenta la view registrta in precedenza ed il parametro menu viene messo a disposizione per creare le singole voci di menù.

Le varie voci di menù si crano come in precedenza ed è possibile assegnare una headerIcon ed un headerTitle al menù in modo da poter un feedback grafico maggiore all’utente.

Ad esempio il seguente codice

@Override
 public void onCreateContextMenu(ContextMenu menu, View v,    ContextMenuInfo menuInfo) {
    menu.setHeaderIcon(android.R.drawable.ic_menu_edit);
    menu.setHeaderTitle("Edit");
    int order = Menu.FIRST;
    menu.add(100, 1, order++, "Copia");
    menu.add(100, 2, order++, "Incolla");
    menu.add(100, 3, order++, "Taglia");
 }

genera questo menù contestuale :

Per intercettare la selezione di un item di menù di questo tipo,

l’activity deve implemntare il metodo

public  boolean onContextItemSelected(MenuItem item)

Inflating XML

Abbiamo visto in precedenza come sia possibile creare dei menù dinamicamente utilizzando (poche) righe di codice Java direttamente nei metodi preposti alla creazione dei menù. In realtà anche questo non è strettamente necessario. Infatti è possibile scrivere un file XML che definisce il menù e poi associarlo all’activity così come viene fatto per il layout della View.

Essendo un file di risorsa il file XML che deve essere menorizzato in res/menu

Un esempio di file XML (mymenu.xml) potrebbe essere il seguente:

<?xml version="1.0" encoding="utf-8"?>
<menu  xmlns:android="http://schemas.android.com/apk/res/android" >
   <item android:id="@+id/item01" android:title="Agenda" />
   <item android:id="@+id/item02" android:title="Call"  />
   <item android:id="@+id/item03" android:title="Preferences"  />
   <item android:id="@+id/item03" android:title="Revert"  />
</menu>

mentre il codice per memorizzare il menù :

@Override
public boolean onCreateOptionsMenu(Menu menu) {
   super.onCreateOptionsMenu(menu);
   MenuInflater mInflater = getMenuInflater();
   mInflater.inflate(R.menu.mymenu, menu);
   return true;
 }

Ecco anche l’esito del menù visualizzato.

L’unica pecca (come si vede) è che in questo modo le icone da indicare possono essere solo quelle presenti nella cartella res dell’applicazione e non quelle di android. E se non si indicano il risultato è alquanto bruttino o perlomeno “vintage”.

che funziona allo stesso modo visto in precedenza, e cioè, tramite l’ itemId si decide cosa fare tipicamente in un ciclo di switch.