Corso su Android – UIControls

titleImage

Bentornati al nostro corso su Android. Quando si usa un'applicazione la prima cosa che salta all'occhio è l'interfaccia grafica con cui l'utente interagisce. Abbiamo visto, di recente, come posizionare i componenti tramite i layout; andiamo, ora, a vedere quali sono quelli che possiamo utilizzare per costruire le nostre Activity.

Android fornisce un'ampia varietà di componenti visuali per disegnare interfacce grafiche e permettere all'utente di interagire con l'applicazione e alcuni di questi li abbiamo visti negli esempi precedenti.
Abbiamo visto i layout che ci permettono di posizionare diversi tipi di View, dove per view si intende un oggetto che disegna qualcosa sullo schermo e permette all'utente di interagire con l'applicazione
Le view vengono definite all'interno di un file xml, come abbiamo visto negli esempi precedenti.
Di seguito elenchiamo i componenti messi a disposizione da Android per costruire le interfacce grafiche:

TextView Utilizzato per visualizzare del testo all'utente
EditText   Campo editabile per dare la possibilità all'utente di inserire valori
AutoCompleteTextView   È una view molto simile all'EditText eccetto per il fatto che visualizza suggerimenti per completare automaticamente la parola
Button   Può essere premuto o cliccato per far eseguire un'azione all'utente
CheckBox   Componente che può assumere valori on/off.
RadioButton   Componente con due stati: selezionato o deselezionato
RadioGroup   Usato per raggruppare i RadioButton
ImageButton   Button con un'immagine che può essere premuto
ToggleButton   Un bottone con un indicatore on/off
ProgressBar   Utilizzato per dare un feedback di avanzamento all'utente
Spinner   Una lista espandibile che permette all'utente di selezionare un valore
TimePicker   Permette all'utente di selezionare le ore
DatePicker   Permette all'utente di selezionare una data

Analizziamoli singolarmente facendo degli esempi pratici. Creiamo un progetto con un'activity in cui inseriremo i vari componenti ed introdurremo un nuovo layout, ScrollView, non ancora utilizzato ma utile se i componenti che compongono la nostra view superano la dimensione dello schermo.
Creiamo un progetto che chiameremo UIControlsProject :

  • premere menu File-->New--> Android Application Project
  • inserire il nome UICOntrolsProject
  • premere Next
  • deselezionare la voce Create custom launcher icon
  • premere Next
  • lasciare la scelta di default
  • premere Next
  • nella schermata successiva premere Finish

Quando si crea il progetto, il plugin non da la possibilità di scegliere il layout del file activity_main.xml, quindi apriamo il file e sostituiamo il codice con:

<ScrollView
    xmlns:android         = "http://schemas.android.com/apk/res/android"
    xmlns:tools           = "http://schemas.android.com/tools"
    android:layout_width  = "match_parent"
    android:layout_height = "match_parent"
    >
    <LinearLayout
        android:layout_width    = "match_parent"
        android:layout_height   = "wrap_content"
        android:orientation     = "vertical"
    >
        <TextView
            android:layout_width   = "wrap_content"
            android:layout_height  = "wrap_content"
            android:text           = "@string/hello_world" />
    </LinearLayout>
</ScrollView>

La struttura è molto semplice, c'è uno ScrollView generale, seguito da un LinearLayout su cui andremo ad aggiungere tutti i componenti.
Attenzione: lo ScrollView può contenere un solo figlio. Nel nostro caso un LinearLayout

TextView

Il TextView è un componente grazie al quale è possibile visualizzare del testo all'utente. Vedendo il progetto appena creato si nota che il plugin mette una TextView automaticamente, infatti abbiamo riprodotto il progetto HelloWorld visto nel primo tutorial.

<TextView
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:text="@string/hello_world" />

EditText

Il componente EditText permette ad un utente di digitare del testo nell'applicazione. Può essere costituito da una singola linea o da più linee. Per scrivere all'interno del campo basta toccare il componente così da far apparire la tastiera. Il campo può assumere diversi tipi di inserimento(number, date, password…) che determinano quali caratteri possono essere inseriti e quale tastiera far apparire per ottimizzare l'inserimento.
Un esempio di EditTetxt può essere il seguente:

<EditText
    android:id           = "@+id/password"
    android:layout_width = "fill_parent"
    android:layout_height= "wrap_content"
    android:hint         = "@string/password_hint"
    android:inputType    = "textPassword" />

dove l'attributo inputType definisce il campo come tipo password, il che significa che i caratteri che verranno digitati saranno sostituiti da un "*".
Ci sono diversi altri tipi di input che possono essere utilizzati: text, textEmailAddress, texture, number, phone, etc.
Copiamo il codice visto sopra dell'EditText subito sotto la TextView nel file activity_main.xml del nostro progetto, aggiungiamo nel file string.xml la definizione della stringa <string name="password_hint">Password</string>

e lanciamo l’applicazione otterremo il risultato in figura:

Toccando sul campo appare la tastiera e provando a digitare dei caratterei si può notare che i caratteri digitati appaiono come asterischi perché il campo è definito come textPassword.

AutoCompleteTextView

Se in un campo di testo si vogliono dare dei suggerimenti è possibile utilizzare una sottoclasse di EditText chiamata AutoCompleteTextView. Per implementare questo campo occorre definire un adapter che fornisce i suggerimenti.
Di seguito vediamo come è possibile implementare un AutoCompleteTextView utilizzando un ArrayAdapter. Inserite il codice seguente sotto la definizione dell’EditText già immesso in precedenza:

<AutoCompleteTextView
  style                       = "@android:style/Theme.Black"
  android:id                  = "@+id/idColor"
  android:layout_width        = "fill_parent"
  android:layout_height       = "wrap_content"
  android:completionThreshold = "1"
 />

Definire un array che contiene tutti I suggerimenti. Definire un array in (res/values/strings.xml):

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="color_array">
        <item>Red</item>
        <item>Green</item>
        <item>Blue</item>
        <item>Black Samoa</item>
    </string-array>
</resources>

Nell'Activity usare il codice seguente:

AutoCompleteTextView textView = (AutoCompleteTextView) findViewById(R.id.idColor);
        // recupera l’array di stringhe
        String[] colors = getResources().getStringArray(R.array.color_array);
        // Crea l’adapter
        ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,
                            android.R.layout.simple_list_item_1, colors);
textView.setAdapter(adapter);

Abbiamo così creato un ArrayAdapter che lega ogni item dell'array di stringhe con la TextView.
Effettuando il run del progetto si può vedere come, digitando sul campo, vengano presentati i suggerimenti disponibili:

Button and ImageButton

Un bottone può essere visto come un testo, un'immagine o entrambi e se viene premuto scatena un evento che può essere intercettato per effettuare un'azione.
A seconda di come si vuole il bottone (testo, immagine, testo e immagine) possiamo crearlo come segue:

  •  solo testo utilizzando la classe Button:
<Button
  android:id            = "@+id/idButton1"
  android:layout_width  = "wrap_content"
  android:layout_height = "wrap_content"
  android:text          = "@string/button_text"
/>
  • con un'icona utilizzando la classe ImageButton
<ImageButton
    android:layout_width  = "wrap_content"
    android:layout_height = "wrap_content"
    android:src           = "@drawable/button_icon"
/>
  • con testo ed icona utilizzando la classe Button e l'attributo android:drawableLeft:
<Button
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/button_text"
    android:drawableLeft="@drawable/button_icon"
/>

Quando abbiamo creato un bottone in uno dei modi visti sopra, bisogna implementare un listener per intercettare l'evento di pressione del tasto.

Android mette a disposizione due modi per definire un evento di "click":

  • direttamente dall'xml, aggiungendo l'attributo android:onClick, il cui valore sarà un metodo definito nell'Activity
<Button
  android:id                  = "@+id/idButton1"
  android:layout_width        = "wrap_content"
  android:layout_height       = "wrap_content"
  android:text                = "@string/button_text"
  android:onClick             = "pressMethod"
/>
  • da codice, mediante l'implementazione del metodo onClickListaner

Questa modalità è quella vista negli esempi degli articoli precedenti, dove viene recuperato il button dall'xml e poi associato ad un listener

ImageButton btnImg = (ImageButton)findViewById(R.id.idImageButton);
        btnImg.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                pressMethod(v);
            }
        });
        
        Button btn2 = (Button)findViewById(R.id.idButton2);
        btn2.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                pressMethod(v);
            }
        });

Dove il metodo pressMethod è definito come:

public void pressMethod(View view){
        Toast.makeText(this, getString(R.string.labelPressed), Toast.LENGTH_SHORT).show();
}

Dopo aver inserito i componenti nel file xml, sempre sotto quelli precedenti, dopo aver implementato il metodo pressMethod e onClickListener e definito le stringhe nel file string.xml, si può far girare il progetto ed il risultato è quello in figura:

Checkbox

I checkbox sono dei componenti che permettono all'utente di poter scegliere una o più opzioni di una lista. Questi possono essere creati nel file di layout utilizzado il conponente CheckBox.
Inseriamo, nel nostro file, i due checkbox, notando che il secondo risulterà "spuntato" grazie all'attributo: android:checked= "true"
Per definire un evento di click si hanno due modi come nel caso del Button: i due metodi visti nei casi precedenti per intercettare gli eventi (ormai abbiamo capito come funzionano) ed andiamo ad utilizzare l'attributo android:onClick nel tag <CheckBox>

<CheckBox
   android:id                  = "@+id/idCheck1"
   android:layout_width        = "wrap_content"
   android:layout_height       = "wrap_content"
   android:text                = "@string/labelCheckBox1"
   android:onClick             = "performCheckBoxOnClick"
/>
<CheckBox
   android:id                  = "@+id/idCheck2"
   android:layout_width        = "wrap_content"
   android:layout_height       = "wrap_content"
   android:text                = "@string/labelCheckBox2"
   android:checked             = "true"
   android:onClick             = "performCheckBoxOnClick"
/>

Nella classe definiamo il metodo

public void performCheckBoxOnClick(View view) {
 //Check if the view is checked
 boolean checked = ((CheckBox) view).isChecked();
    
 switch(view.getId()) {
   case R.id.idCheck1:
      if (checked){
         Toast.makeText(this, getString(R.string.labelChecked1), 
                  Toast.LENGTH_SHORT).show();
      }else {
         Toast.makeText(this, getString(R.string.labelNotChecked1), 
                  Toast.LENGTH_SHORT).show();
      }
   break;
   case R.id.idCheck2:
      if (checked){
         Toast.makeText(this, getString(R.string.labelChecked2), 
                  Toast.LENGTH_SHORT).show();
      }else {
         Toast.makeText(this, getString(R.string.labelNotChecked2), 
                  Toast.LENGTH_SHORT).show();
      }
   break;
  }
}

dove viene controllato se il checkbox premuto è selezionato o meno e viene visualizzato un messaggio. Dopo aver definito le stringhe necessarie nel file string.xml

<string name="labelCheckBox1">Check 1</string>
<string name="labelCheckBox2">Check 2</string>
<string name="labelChecked1">Il CheckBox 1 è selezionato</string>
<string name="labelNotChecked1">Il CheckBox 1 non è selezionato</string>
<string name="labelChecked2">Il CheckBox 2 è selezionato</string>
<string name="labelNotChecked2">Il CheckBox 2 non è selezionato</string>

si può eseguire il run del progetto e verrà visualizzata la schermata seguente:

RadioButton and RadioGroup

Permette all'utente di selezionare un'opzione da un insieme e la scelta è mutualmente esclusiva, ossia tra n opzioni solo una è selezionabile e le altre sono escluse (diversamente dai checkbox dove è possibile effettuare selezioni multiple).
Per creare un radio button si utilizza il tag RadioButton, però, essendo mutualmente esclusivo, viene inserito all'interno del tag RadioGroup.
Anche per i RadioButton si utilizzano i due metodi visti nei casi precedenti per intercettare gli eventi. Ormai abbiamo capito come funzionano per cui andiamo ad utilizzare l'attributo android:onClick nel tag <RadioButton> ed inserendo l'attributo android:checked= "true" nel primo RadioButton così da indicare che è selezionato di default

<RadioGroup
            android:layout_width        = "fill_parent"
            android:layout_height       = "wrap_content"
            android:orientation         = "vertical">
            <RadioButton
                android:id              = "@+id/idRadio1"
                android:layout_width    = "wrap_content"
                android:layout_height   = "wrap_content"
                android:text            = "@string/labelRadio1"
                android:onClick         = "onRadioButtonClicked"
                android:checked            = "true"/>
            <RadioButton
               android:id               = "@+id/idRadio2"
                android:layout_width    = "wrap_content"
                android:layout_height   = "wrap_content"
                android:text            = "@string/labelRadio2"
                android:onClick         = "onRadioButtonClicked"/>/>
        </RadioGroup>

Definiamo il metodo:

public void onRadioButtonClicked(View view) {
        
        boolean checked = ((RadioButton) view).isChecked();
        
        switch(view.getId()) {
            case R.id.idRadio1:
                if (checked){
                    Toast.makeText(this, getString(R.string.labelRadioCheched1), 
                         Toast.LENGTH_SHORT).show();
                }
                break;
            case R.id.idRadio2:
                if (checked){
                    Toast.makeText(this, getString(R.string.labelRadioCheched2), 
                         Toast.LENGTH_SHORT).show();
                }
                break;
        }
    }

ed inseriamo le stringhe

<string name="labelRadio1">Radio 1</string>
<string name="labelRadio2">Radio 2</string>
<string name="labelRadioCheched1">Il RadioButton 1 è selezionato</string>
<string name="labelRadioCheched2">Il RadioButton 2 è selezionato</string>

Effettuano il run del progetto si ottiene il risultato in figura:

ToggleButton

Un toggle button permette all'utente di selezionare due stati (on/off).
Per vedere come intercettare l'handler utilizziamo l'attributo android:onClick nel tag <ToggleButton>

<ToggleButton
     android:id                  = "@+id/idToggle"
     android:layout_width        = "wrap_content"
     android:layout_height       = "wrap_content"
     android:textOn              = "@string/labelToggleOn"
     android:textOff             = "@string/labelToggleOff"
     android:onClick             = " onToggleOnClick"
/>

Si nota che vengono definiti due test uno per lo stato "on" e l'altro per lo stato "off". Definiamo il metodo
Il risultato dopo aver definito le stringhe è il seguente:

Spinner

Un componente spinner permette di selezionare un valore da una lista, infatti appena viene premuto viene visualizzata una lista di opzioni da scegliere.
Questo può essere aggiunto nel layout utilizzando il tag Spinner :

<Spinner
   android:id              = "@+id/idColors"
   android:layout_width    = "fill_parent"
   android:layout_height   = "wrap_content"
/>

Per popolare lo Spinner si può utilizzare un ArrayAdapter. Utilizziamo lo <string-array> impiegato per l'esempio su AutoCompleteTextView

Spinner spinner = (Spinner) findViewById(R.id.idSpinnerColors);
final ArrayAdapter<CharSequence> adapterSpinner = ArrayAdapter.createFromResource(this,
        R.array.color_array, android.R.layout.simple_spinner_item);
adapterSpinner.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
        spinner.setAdapter(adapterSpinner);

Abbiamo recuperato lo Spinner dal file xml, abbiamo creato un arrayAdapter grazie al metodo createFromResource() e definito il layout per visualizzare la lista con la scelta usando setDropDownViewResource()
Andiamo, adesso, a definire un Listener per intercettare gli eventi scatenati dalla pressione su un elemento della lista

spinner.setOnItemSelectedListener(new OnItemSelectedListener() {

  @Override
  public void onItemSelected(AdapterView<?> parent, View view,
                    int pos, long id) {
    Toast.makeText(context,"selezionato [" + 
          (String)adapterSpinner.getItem(pos)+ "]", Toast.LENGTH_SHORT).show();
  }

  @Override
  public void onNothingSelected(AdapterView<?> parent) {
   }
 });

Eseguendo il run del progetto si ottiene la schermata precedente con l'aggiunta alla fine dello Spinner, premendo il quale si ottiene la schermata successiva:

Notate che la visualizzazione di questo componente varia a seconda del SO; infatti la schermata sopra è stata presa da un HTC Desire con Android 2.2.2 mentre quella successiva da un S3 con Android 4.1.2

TimePicker DatePicker

Android mette a disposizione dell'utente dei componenti grafici che permettono di scegliere l'ora in ore-minuti-AM/PM (TimePicker) e la data in giorno-mese-anno (DatePiker). Grazie a questi componenti si forza l'utente a scegliere una data ed un'ora valida e formattata correttamente.
Entrambi i componenti possono essere utilizzati direttamente nel layout oppure visualizzati tramite un dialog. Noi vedremo la seconda modalità che è, di solito, la più utilizzata.
Per vedere come funziona inseriamo nel nostro layout un EditText con vicino un Button e premendolo verrà visualizzato il DatePicker. Una volta selezionata la data, essa verrà visualizzata nel campo di testo. Per far questo utilizziamo un TableLayout con una riga al cui interno vi è un EditText ed un Button. Il codice è il seguente e va inserito nel file xml:

<TableLayout
            android:layout_width    = "fill_parent"
            android:layout_height    = "wrap_content"
            android:stretchColumns    = "0"
        >
            <TableRow >
                <EditText
                    android:id                = "@+id/idDatePicker"
                    android:layout_width    = "fill_parent"
                    android:layout_height    = "wrap_content"
                />
                <Button
                    android:id                = "@+id/idBtnOpenDatePicker"
                    android:layout_width    = "wrap_content"
                    android:layout_height    = "wrap_content"
                    android:text            = "@string/btnLabelOpenDatePicker"
                />
            </TableRow>
        </TableLayout>

Notare che nel tag TableLayout abbiamo messo l'attributo android:stretchColumns= "0",visto nell'articolo dove abbiamo parlato dei layout, che allarga la prima colonna così da far occupare più spazio al campo di testo.
Ora nel file string.xml definiamo la stringa <string name="btnLabelOpenDatePicker">Set Date</string>

Nota: Dalla versione 3.0 sono state introdotte nuove classi per gestire il ciclo di vita dei DatePicker e TimePicker. Andremo ad utilizzare DialogFragment introdotto dalla versione 3.0 di Android ma reso retrocompatibile fino alla versione 1.6.

Iniziamo con il creare una nuova classe DatePickerFragment che estenderà il nostro DialogFrament e visualizzerà il DataPicker

public class DatePickerFragment extends DialogFragment {
    public static final String YEAR    = "year";
    public static final String MONTH    = "month";
    public static final String DAY    = "day";
    
    private OnDateSetListener listener    = null;
    private int year;
    private int month;
    private int day;
    
    public DatePickerFragment() {}
 //setta il listener per la risposta
    public void setCallBack(OnDateSetListener listener) {
        this.listener = listener;
    }

 //setta anno mese e giorno da passare al DatePicket
    @Override
    public void setArguments(Bundle args) {
        super.setArguments(args);
        year     = args.getInt(YEAR);
        month = args.getInt(MONTH);
        day     = args.getInt(DAY);
    }    
  //visualizza il dialog con il DatePicker
    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        return new DatePickerDialog(getActivity(), listener, year, month, day);
    }
}  

Passiamo ora alla classe principale e come prima cosa cambiamo la classe con cui viene estesa mettendo al posto di Activity la classe FragmentActivity

public class MainActivity extends FragmentActivity{.....

definiamo la variabile

private EditText edDate    = null;

recuperiamo il campo di testo nel metodo OnCreate:

edDate = (EditText)findViewById(R.id.idDatePicker);

recuperare il Button dal layout ed associargli un listener.
Andiamo ad aggiungere il metodo per visualizzare il Dialog ed il listener per intercettare il risultato scelto.

private void showDatePicker() {
//instanzia la classe
        DatePickerFragment date = new DatePickerFragment();
        /*recupera i valori per visualizzare la data attuale */
        Calendar calender = Calendar.getInstance();
        Bundle args = new Bundle();
        args.putInt(DatePickerFragment.YEAR,     calender.get(Calendar.YEAR));
        args.putInt(DatePickerFragment.MONTH,     calender.get(Calendar.MONTH));
        args.putInt(DatePickerFragment.DAY, calender.get(Calendar.DAY_OF_MONTH));
        date.setArguments(args);
        
        date.setCallBack(listener);
        date.show(getSupportFragmentManager(), "DatePicker");
    }
OnDateSetListener listener = new OnDateSetListener() {
        @Override
        public void onDateSet(DatePicker view, int year, int monthOfYear,int dayOfMonth) {
            edDate.setText(dayOfMonth + "/" + monthOfYear + "/" + year);
            
         }
    };

Nel metodo showDatePicker viene instanziata la classe da noi definita DatePickerFragment, viene recuperata la data attuale tramite l'oggetto Calendar e viene passato alla classe tramite un Bundle. Alla fine viene invocato il metodo show per visualizzare il DatePicker. Viene settato il listener definito da noi come metodo di callBack così, nel momento in cui viene scelta la data, viene invocato questo metodo al cui interno vengono recuperati i dati di mese, giorno e anno, viene costruita una stringa e assegnata all'EditText.

Per finire, inseriamo il codice che prende il Button ed implementa il metodo onClick al cui interno si richiama il metodo showDatePicker

Button openDP    = (Button)findViewById(R.id.idBtnOpenDatePicker);
        openDP.setOnClickListener(new OnClickListener() {
            

            @Override
            public void onClick(View v) {
                showDatePicker();
            }
        });

Il TimePicker è praticamente molto simile al DataPicker ed anche il modo di invocazione è analogo. Andremo più spediti:

  • creiamo la classe TimePickerFragment:
public class TimePickerFragment extends DialogFragment {
        public static final String HOUR        = "hour";
    public static final String MINUTE    = "minute";
    
    private OnTimeSetListener listener    = null;
    private int hour;
    private int minute;
    
    
    public TimePickerFragment() {}

    //setta il listener per la risposta
    public void setCallBack(OnTimeSetListener listener) {
        this.listener = listener;
    }

    //setta ora e minuti da passare al TimePicker
    @Override
    public void setArguments(Bundle args) {
        super.setArguments(args);
        hour     = args.getInt(HOUR);
        minute     = args.getInt(MINUTE);
        
    }    

    //visualizza il dialog con il TimePicker
    @Override
    public Dialog onCreateDialog(Bundle savedInstanceState) {
        return new TimePickerDialog(getActivity(), listener, hour, 
                 minute,DateFormat.is24HourFormat(getActivity()));

    }
}  

Dove il metodo DateFormat.is24HourFormat recupera le informazioni settate per l'ora di sistema, ossia se l'utente visualizza l'ora con formato 24 ore oppure 12 ore. Questo influisce sulla visualizzazione del TimePiker.

  • Aggiungiamo nel file xml:
<TableLayout
            android:layout_width    = "fill_parent"
            android:layout_height   = "wrap_content"
            android:stretchColumns  = "0"
        >
            <TableRow >
                <EditText
                    android:id              = "@+id/idTimePicker"
                    android:layout_width    = "fill_parent"
                    android:layout_height   = "wrap_content"
                />
                <Button
                    android:id              = "@+id/idBtnOpenTimePicker"
                    android:layout_width    = "wrap_content"
                    android:layout_height   = "wrap_content"
                    android:text            = "@string/btnLabelOpenTimePicker"
                />
            </TableRow>
        </TableLayout>

Aggiungiamo la stringa nel file string.xml

<string name="btnLabelOpenTimePicker">Set Time</string>

Aggiungere nell'activity:

edTime = (EditText)findViewById(R.id.idTimePicker);
  • ed i metodi:
Button openTP    = (Button)findViewById(R.id.idBtnOpenTimePicker);
        openTP.setOnClickListener(new OnClickListener() {
            

            @Override
            public void onClick(View v) {
                showTimePicker();
            }
        });

private void showTimePicker() {
        TimePickerFragment date = new TimePickerFragment();
        /*recupera i valori per visualizzare la data attuale */
        Calendar calender = Calendar.getInstance();
        Bundle args = new Bundle();
        args.putInt(TimePickerFragment.HOUR,     calender.get(Calendar.HOUR_OF_DAY));
        args.putInt(TimePickerFragment.MINUTE,     calender.get(Calendar.MINUTE));
        
        date.setArguments(args);
        
        date.setCallBack(listenerTime);
        date.show(getSupportFragmentManager(), "TimePicker");
    }

    OnTimeSetListener listenerTime = new OnTimeSetListener() {

        @Override
        public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
            edTime.setText(hourOfDay + ":" + minute);
        }
        
    };

A questo punto non resta che eseguire il run del progetto.

Conclusioni

Dopo aver visto  come funzionano i Layout ed i tipi più comuni di componenti grafici, siamo in grado di creare  applicazioni graficamente complesse che non hanno nulla da invidiare a quelle che si trovano sul market.

Seguiteci nelle prossime puntate dove vedremo dei progetti in cui applicare le nozioni acquisite fino ad ora che stanno alla base della programmazione in ambiente Android, grazie alle quali è possibile iniziare a sviluppare applicazioni complesse.

In ultimo, sapppiate che il prossimo mese questo corso farà una breve pausa. Ma non preoccupatevi: è solo per tornare a stupirvi a Marzo con i progetti. Sì perchè la parte introduttiva è ormai conclusa, il grosso dei concetti e degli strumenti sono stati illustrati.

Ovviamente, sono e resto a vostra disposizione qui nei commenti per ogni genere di chiarimento e/o domanda sul corso e se ci dovessero essere richieste di approfondimenti potremo certamente discuterne insieme.

Anzi, se avete delle preferenze, delle richieste specifiche, su app da sviluppare nel corso della seconda parte, o volete voi stessi proporre del codice o lo sviluppo di un'applicazione, siete i benvenuti.

 

Quello che hai appena letto è un Articolo Premium reso disponibile affinché potessi valutare la qualità dei nostri contenuti!

 

Gli Articoli Tecnici Premium sono infatti riservati agli abbonati e vengono raccolti mensilmente nella nostra rivista digitale EOS-Book in PDF, ePub e mobi.
volantino eos-book1
Vorresti accedere a tutti gli altri Articoli Premium e fare il download degli EOS-Book? Allora valuta la possibilità di sottoscrivere un abbonamento a partire da € 2,95!
Scopri di più

10 Comments

  1. Giorgio B. Giorgio B. 9 gennaio 2014
  2. Giorgio B. Giorgio B. 9 gennaio 2014
  3. Piero Boccadoro Piero Boccadoro 9 gennaio 2014
  4. Piero Boccadoro Piero Boccadoro 9 gennaio 2014
  5. FabrizioG 11 gennaio 2014
  6. Giorgio B. Giorgio B. 23 gennaio 2014
  7. FabrizioG 23 gennaio 2014
  8. Alessandro.Buscema 30 gennaio 2014
  9. FabrizioG 31 gennaio 2014
  10. Alessandro.Buscema 31 gennaio 2014

Leave a Reply

Flip&Click Arduino e Python compatibile

Fai un abbonamento Platinum (EOS-Book + Firmware), ricevi in OMAGGIO la nuova Flip&Click, inviaci il tuo progetto e OTTIENI IL RIMBORSO