Autore Topic: [facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)  (Letto 36900 volte)

Offline maku85

  • Nuovo arrivato
  • *
  • Post: 28
  • Respect: +35
    • Mostra profilo
  • Dispositivo Android:
    Sony Xperia J
  • Play Store ID:
    MaKu
  • Sistema operativo:
    Windows 8.1
+14
Livello di difficoltà: facile
Link al file compresso del progetto eclipse: file in allegato

Le finestre di dialogo sono dei riquadri che è possibile aprire al di sopra dell'attività corrente bloccandola temporaneamente in attesa dell'interazione dell'utente. Ne sono un esempio le finestre di conferma che chiedono all'utente se proseguire o meno con una determinata operazione. Quindi a differenza dei toast le finestre di
dialogo sono sia bloccanti che interattive.

Per poterle utilizzare si fa riferimento alla classe android.app.Dialog che definisce con i suoi metodi cosa una finestra di dialogo può fare e come può essere manipolata.

Iniziamo definendo il ciclo di vita di una finestra di dialogo.

Ogni volta che vogliamo visualizzarne una bisogna richiamare il metodo showDialog(id), dove il parametro id  è un intero e simboleggia quale specifica finestra deve essere visualizzata. Il valore è arbitrario, cioè
siamo noi che dobbiamo creare le finestre di dialogo ed assegnargli degli identificativi (di solito si consiglia di usare delle costanti interne alla classe dell'attività).
Ad esempio se abbiamo intenzione di utilizzare due finestre, una per segnalare un errore e una di conferma è meglio aggiungere due costanti prima di richiamare il metodo showDialog(id)
Codice (Java): [Seleziona]
private static final int DIALOG_ERROR_ID=1;
private static final int DIALOG_CONFIRM_ID=2;

showDialog(DIALOG_ERROR_ID);
showDialog(DIALOG_CONFIRM_ID);

Ma prima di poter effettivamente visualizzare le finestre di dialogo dobbiamo informare Android a quali tipi di finestre corrispondano effettivamente i due interi indicati e per farlo dobbiamo ridefinire il metodo onCreateDialog(id) poichè Android richiama questo metodo ogni volta che deve creare una finestra di
dialogo in base al parametro id che gli viene fornito. Dobbiamo quindi ridefinire il metodo per riconoscere l'identificativo che viene passato, costruire la finestra di dialogo e restituirla sottoforma di oggetto android.app.Dialog.
Per ridefinire il metodo di solito si usa questo schema:
Codice (Java): [Seleziona]
protected Dialog onCreateDialog(int id) {
    Dialog dialog;
    switch(id) {
    case DIALOG_ERROR_ID:
        // definire cosa fare in caso di errore
        break;
    case DIALOG_CONFIRM_ID:
        // definire cosa fare in caso di conferma
        break;
    default:
        dialog = null;
    }
    return dialog;
}

sfruttando così il metodo switch per associare degli oggetti Dialog ai loro corrispettivi identificativi numerici.
Dopo che la finestra è stata creata Android prima di mostrarla richiama il metodo onPrepareDialog(id,dialog), che riceve come parametri l'identificativo della finestra e l'oggetto Dialog costruito prima. Anche questo metodo si può ridefinire per inizializzare la finestra con dei comandi specifici
Codice (Java): [Seleziona]
protected void onPrepareDialog(int id,Dialog dialog){
        switch(id){
                ...
        }
}

Bisogna specificare però che il metodo onCreateDialog(id) per uno specifico id viene richiamato solo la prima volta che la corrispondente finestra deve essere mostrata. La seconda volta che la stessa finestra verrà richiamata il sistema farà riuso dell'istanza già esistente, quindi se bisogna inizializzare l'istanza in maniera
differente alla volta precedente non resta che farlo ridefinendo onPrepareDialog(id,dialog).
Dopo che una finestra viene aperta la si può chiudere in due modi:
- la può chiudere direttamente l'utente servendosi del tasto "back"del telefonino (se ciò gli viene consentito, come vedremo dopo)
- oppure sempre via codice invocando il metodo definito come dismissDialog(id).
in questo modo la finestra viene chiusa e nascosta ma come detto prima rimane un riferimento all'oggetto e se richiamata è possibile riutilizzarla.
Se invece la si vuole eliminare definitivamente si utilizza il metodo removeDialog(id).
Dunque possiamo dire che di solito si usa il metodo dismissDialog(id) per le finestre usate frequentemente e removeDialog(id) per chiudere quelle usate raramente.

Aggiunta:
Se si vuole fare in modo che l'applicazione compia qualcosa quando viene chiusa si può utilizzare un "on-dismiss listener", cioè un "ascoltatore" che ci avvisi quando viene richiamato il metodo dismissDialog(id) per chiudere la finestra.
Per farlo bisogna prima definire l'interfaccia DialogInterface.OnDismissListener che ha solo un metodo, onDismiss(DialogInterface) che viene richiamato quando la finestra di dialogo viene chiusa, dopodichè bisogna passare l'implementazione dell'interfaccia al metodo setOnDismissListener(). Come abbiamo detto però le finestre a volte possono essere chiuse in altri modi, possono essere "cancellate"
dall'utente(utilizzato il tasto back) oppure chiuse utiliizando il metodo cancel() al posto del solito dismissDialog(id). In questo caso l'ascoltatore costruito prima non funziona più, bisogna invece utilizzare un'altra interfaccia DialogInterface.OnCancelListener con il metodo setCancelListener().

Definita il ciclo di vita delle finestre di dialogo procediamo a costruirne e amministrarne una.

Di solito non si usa direttamente la classe Dialog ma alcune sue sottoclassi presenti nella libreria come android.app.AlertDialog e android.app.ProgressDialog

La classe AlertDialog definisce le finestre utilizzare per mostrare un avviso o per chiedere all'utente qualcosa(una conferma o la selezione di un elemento da una lista) e può avere da 1 a 3 tasti e/o una lista di oggetti che può includere anche checkboxes o bottoni radio.
Esempio:


Per creare una finestra di avviso procediamo in questo modo:
Codice (Java): [Seleziona]
AlertDialog.Builder builder=new AlertDialog.Builder(this);
builder.setTitle("Avviso");
builder.setMessage("Attenzione!Questo è un avviso");
builder.setCancelable(true);
AlertDialog alert=builder.create();

come si vede dal codice la finestra viene creata servendosi di uno speciale oggetto AlertDialogBuilder al quale bisogna comunicare le caratteristiche desiderate(nel nostro caso abbiamo impostato il titolo e il messaggio ma vi sono altri metodi). Con setCancelable(true) abbiamo fatto in modo che l'avviso possa essere chiuso
con il tasto "back" del telefono e infine con il metodo create() viene effettivamente creata. A questo punto la finestra può essere restituita dal metodo onCreateDialog().
Se invece non vogliamo che l'utente possa utilizzare il tasto "back" ma vogliamo fornire un tasto "Chiudi" procediamo invece in questo modo:
Codice (Java): [Seleziona]
AlertDialog.Builder builder=new AlertDialog.Builder(this);
builder.setTitle("Avviso");
builder.setMessage("Attenzione!Questo è un avviso");
builder.setCancelable(false);
builder.setPositiveButton("Chiudi",new DialogInterface.onClickListener(){
        public void onClick(DialogInterface dialog, int id){
                dialog.dismiss();
                }
        });

al metodo setPositiveButton() utilizzato per aggiungere il tasto "chiudi" bisogna fornire un oggetto di tipo android.content.DialogInterface.OnClickListener che non è altro che un gestore di eventi richiamato alla pressione del tasto in questione che dovrà quindi richiamare il metodo dismissDialog(). Si possono aggiungere al massimo tre tasti chiamati "positive","neutral" e "negative" (quindi uno per ogni genere). Non
bisogna farsi trarre in inganno dal nome dei tasti poichè sono tutti uguali e il nome serve solo per aiutare il programmatore a non confondersi.
Se invece vogliamo fornire la facoltà di scegliere più opzioni possiamo inserire un elenco:
Codice (Java): [Seleziona]
final String[] options={"Primo","Secondo","Terzo","Quarto","Quinto"};
AlertDialod.Builder builder=new AlertDialogBuilder(this);
builder.setTitle("Scelta multipla");
builder.setItems(options,new DialogInterface.onClickListener(){
public void onClick(DialogInterface.onClickListener(){
...

in questo caso non si usa nè il metodo relativo all'impostazione del messaggio nè quello relativo ai tasti ma solo il metodo setItems() che necessita come argomenti un array di stringhe(ogni stringa sarà un'opzioen di scelta) e il gestore di eventi. Quando una delle opzioni sarà selezionata il metodo onClick() del gestore verrà automaticamente richiamato. L'argomento which in questo caso riporterà l'indice dell'opzione selezionata.
L'elenco delle opzioni potrà essere popolato con bottoni radio o checkbox, nel primo caso bisogna però utilizzare il metodo setSingleChoicheItems() che vuole tre parametri: l'array di stringhe con le opzioni, l'indice dell'opzione inizialmente selezionata e il gestore di eventi.
Esempio
Codice (Java): [Seleziona]
...
builder.setSingleChoicheItems(options,2,new DialogInterface.onClickListener(){
...

in questo caso però ha senso rimettere i tasti di conferma e cancellazione per poter dare la possibilità all'utente di scegliere l'opzione desiderata dalla lista e poi confermare con l'apposito bottone.
Nel caso di utilizzo dei checkbox invece si richiama il metodo setMultiChoiceItems() che riceve anche esso tre parametri; l'array delle opzioni,un array di booleanj i cui elementi corrispondono a ciascuna delle opzioni
possibili indicando se è selezionata o meno e il terzo e il gestore degli eventi. In questo caso l'interfaccia è DialogInterface.OnMultiChoiceClickListener. Il metodo onClick() si differenzia da quello di OnClickListener perchè prevede un terzo parametro cioè di un booleano chiamato isChecked che serve a indicare se l'opzione toccata dall'utente è stata selezionata o meno.

Come anticipato l'altra classe di finestre di dialogo maggiormente usata è quella relativa alle Progress dialog utilizzate per segnalare all'utente che è in corso un'operazione ed è quindi necessario attendere il suo completamente evitando di fargli pensare che l'applicazione si sia bloccata. La classe da utilizzare è android.app.ProgressDialog e la maniera più semplice per crearne una e utilizzare il metodo statico ProgressDialog.show(context, title, message).
Il metodo crea e restituisce una finestra di attesa indeterminata(cioè senza barra di avanzamento). Richiede come parametri il contesto dell'applicazione(di solito l'attività che sta creando la finestra), il titolo da assegnare alla finestra (che di solito va lasciato vuoto, utilizzando "") e il messaggio da mostrare al suo interno.
Esempio:
Codice (Java): [Seleziona]
protected Dialog onCreateDialog(int id) {
        switch(id) {
        case PROGRESS_DIALOG:
                progressDialog=ProgressDialog.show(ProgressTest.this,"","Caricamento in corso...");
                return progressDialog;
                default:
                        return null;
                        }
        }



La ProgressDialog con barra di avanzamento è più complesso e va costruita manualmente richiamando prima il costruttore
Codice (Java): [Seleziona]
ProgressDialog progress=new ProgressDialog(this);
Dopodichè si procede con il definire le sue caratteristiche: bisogna quindi specificare che la barra non è indeterminata(che ha quindi una barra di avanzamento) con il metodo setIndeterminate(false), che è orizzontale con il metodo setProgressStyle(ProgressDialog.STYLE_HORIZONTAL), il messaggio da
visualizzare con setMessage(String) e se è cancellabile o meno(da parte dell'utente utilizzando il tasto "back" del telefono come per le AlertDialog) con setCancelable(true). L'avanzamento raggiunto è espresso mediante un valore che va da 0 e 100 ma se non è sufficiente per la nostra applicazione si può definire il limite superiore invocando il metodo setMax(int).
A questo punto la finestra di dialogo può essere restituita e visualizzata. Su un thread parallelo bisogna intanto iniziare a svolgere l'operazione di cui l'utente attende la conclusione. Di tanto in tanto, mentre si svolge tale operazione, è necessario aggiornare la barra di avanzamento per informare il punto raggiunto. Per farlo si usa il metodo setProgress(int) che accetta come parametro un valore intero per specificare la percentuale di progresso a cui si è giunti o il metodo incrementProgressBy(int) per incrementare la percentuale del valore intero fornito al metodo.
Esempio:
Codice (Java): [Seleziona]
protected Dialog onCreateDialog(int id) {
        switch(id) {
        case PROGRESS_DIALOG:
                progressDialog = new ProgressDialog(ProgressTest.this);
                progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
                progressDialog.setMessage("Caricamento in corso...");
                progressDialog.setCancelable(true);
                return progressDialog;
                default:
                        return null;
                        }
        }



Aggiunta
Per operazioni più complesse si può anche usare una barra di progresso secondaria.In questo caso ci viene in aiuto il metodo setSecondaryProgress().

Se le AlertDialog e le ProgressDialog non vanno bene si può fare uso di Custom Dialog, cioè di finestre di dialogo personalizzate. In pratica si realizza un layout XML ad esempio con una semplice ImageView e una TextView come il seguente:
Codice (XML): [Seleziona]
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
             android:id="@+id/layout_root"
             android:orientation="horizontal"
             android:layout_width="fill_parent"
             android:layout_height="fill_parent"
             android:padding="10dp"
             >
    <ImageView android:id="@+id/image"
              android:layout_width="wrap_content"
              android:layout_height="fill_parent"
              android:layout_marginRight="10dp"
              />
    <TextView android:id="@+id/text"
             android:layout_width="wrap_content"
             android:layout_height="fill_parent"
             android:textColor="#FFF"
             />
</LinearLayout>

e all'interno del metodo onCreateDialog(id) definiamo gli oggetti del layout
Codice (Java): [Seleziona]
dialog=new Dialog(CustomDialog.this);
dialog.setContentView(R.layout.custom_dialog);
dialog.setTitle("Custom Dialog");              
TextView text = (TextView) dialog.findViewById(R.id.text);
text.setText("Ciao, questo è un custom dialog!");
ImageView image = (ImageView) dialog.findViewById(R.id.image);
image.setImageResource(R.drawable.android);



Aggiunta:
Una finestra di dialogo creata dalla classe base Dialog deve avere un titolo. Se non è stato impostato rimarrà vuoto ma visibile.


Se non lo si vuole visualizzare bisogna creare una finestra usando la classe AlertDialog. Una finestra così creata però non ha accesso al metodo setContentView(id) e bisogna quindi usare il metodo setView(view) che accetta un oggetto View, quindi bisogna "inflatare" il layout dal file XML. Per farlo bisogna recuperare il LayoutInflater con il metodo getLayoutInflater() (o il metodo getSystemService()) e dopo il metodo inflate(int, ViewGroup) dove il primo parametro e l'id del layout e il secondo è l'id della View radice. A qeusto punto si può usare il layout "inflatato" per trovare l'oggetto View nel layout e definire il contenuto per gli elementi ImageView e TextView.
Ad esempio:
Codice (Java): [Seleziona]
AlertDialog.Builder builder;
LayoutInflater inflater = (LayoutInflater) CustomDialog2.this.getSystemService(LAYOUT_INFLATER_SERVICE);
View layout = inflater.inflate(R.layout.custom_dialog,(ViewGroup) findViewById(R.id.layout_root));
TextView text = (TextView) layout.findViewById(R.id.text);
text.setText("Ciao, questo è un custom dialog!");
ImageView image = (ImageView) layout.findViewById(R.id.image);
image.setImageResource(R.drawable.android);
builder = new AlertDialog.Builder(CustomDialog2.this);
builder.setView(layout);
alertDialog = builder.create();


 
Il vantaggio di usare una AlertDialog con un layout customizzato dà il vantaggio di poter utilizzare tutte le caratteristiche di una normale AlertDialog .

Sorgenti:
Bibliografia:
- Il programmatore è colui che risolve in un modo incomprensibile un problema che non sapevi di avere -

Offline JD

  • Amministratore
  • Utente storico
  • *****
  • Post: 1600
  • Respect: +232
    • leinardi
    • Mostra profilo
  • Dispositivo Android:
    LG Nexus 5
  • Sistema operativo:
    L'ultima Ubuntu
Re:[facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)
« Risposta #1 il: 24 Maggio 2011, 20:31:45 CEST »
0
Complimenti, un altro tutorial a regola d'arte :)

Ho una curiosità un po' OT riguardo gli screenshot: sbaglio o sono ritagliati a partire da uno screenshot più grande (presumibilmente l'intero desktop)?

Come mai non li fai tramite il DDMS, che ti fornisce già l'immagine pronta per l'uso?
È stata trovata una soluzione al tuo problema?
Evidenzia il post più utile premendo . È un ottimo modo per ringraziare chi ti ha aiutato ;).
E se hai aperto tu il thread marcalo come risolto cliccando !

Offline bradipao

  • Moderatore globale
  • Utente storico
  • *****
  • Post: 4043
  • keep it simple
  • Respect: +567
    • Github
    • Google+
    • bradipao
    • Mostra profilo
  • Dispositivo Android:
    Nexus 5
  • Play Store ID:
    Bradipao
  • Sistema operativo:
    W7
Re:[facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)
« Risposta #2 il: 24 Maggio 2011, 20:51:02 CEST »
0
Bel tutorial, grazie!!!  :-)
NON rispondo a domande nei messaggi privati
Bradipao @ Play Store

Offline maku85

  • Nuovo arrivato
  • *
  • Post: 28
  • Respect: +35
    • Mostra profilo
  • Dispositivo Android:
    Sony Xperia J
  • Play Store ID:
    MaKu
  • Sistema operativo:
    Windows 8.1
Re:[facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)
« Risposta #3 il: 25 Maggio 2011, 17:07:18 CEST »
0
Grazie!..spero possano servire..
Comunque JD hai ragione..ho fatto una screen del desktop..avevo dimenticato l'utile funzione del DDMS..sarà per la prossima  ;-)
- Il programmatore è colui che risolve in un modo incomprensibile un problema che non sapevi di avere -

Offline cadupper

  • Utente junior
  • **
  • Post: 81
  • Respect: 0
    • cadupper
    • Mostra profilo
  • Dispositivo Android:
    HTC Magic Tim (32A)
  • Play Store ID:
    cadupper
  • Sistema operativo:
    Ubuntu 10.04
Re:[facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)
« Risposta #4 il: 28 Maggio 2011, 09:14:33 CEST »
0
Ottimo tutorial, davvero completo!!
Solo una domanda: io ho la mia lista da visualizzare nel dialog memorizzata in un database e interrogandolo ho ottenuto un adapter con la lista che voglio visualizzare nel dialog. Come faccio ad associarla al dialog? devo per forza trasformare l'adapter in un array?
Ciao e grazie! :D

Offline Nicola_D

  • Moderatore
  • Utente storico
  • *****
  • Post: 2479
  • SBAGLIATO!
  • Respect: +323
    • Github
    • Google+
    • nicoladorigatti
    • Mostra profilo
  • Dispositivo Android:
    Nexus 6p, Nexus 4, Nexus S, Nexus 7(2012)
  • Sistema operativo:
    Windows 7
Re:[facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)
« Risposta #5 il: 28 Maggio 2011, 10:32:15 CEST »
0
Ottimo tutorial, davvero completo!!
Solo una domanda: io ho la mia lista da visualizzare nel dialog memorizzata in un database e interrogandolo ho ottenuto un adapter con la lista che voglio visualizzare nel dialog. Come faccio ad associarla al dialog? devo per forza trasformare l'adapter in un array?
Ciao e grazie! :D
basta guardare la documentazione!
singlechoice: AlertDialog.Builder | Android Developers
multiplechoice: AlertDialog.Builder | Android Developers
dal database cmq ottieni un cursor
« Ultima modifica: 08 Luglio 2011, 11:53:10 CEST da Nicola_D »
IMPORTANTE:NON RISPONDO A PROBLEMI VIA MESSAGGIO PRIVATO
LOGCAT: Non sai cos'è? -> Android Debug Bridge | Android Developers
               Dov'è in Eclipse? -> Window -> Open Prospective -> DDMS e guarda in basso!
[Obbligatorio] Logcat, questo sconosciuto! (Gruppo AndDev.it LOGTFO) - Android Developers Italia

Offline cadupper

  • Utente junior
  • **
  • Post: 81
  • Respect: 0
    • cadupper
    • Mostra profilo
  • Dispositivo Android:
    HTC Magic Tim (32A)
  • Play Store ID:
    cadupper
  • Sistema operativo:
    Ubuntu 10.04
Re:[facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)
« Risposta #6 il: 28 Maggio 2011, 10:34:01 CEST »
0
Grazie! sono riuscito!
Ora l'unico problema è che ho gli item bianchi su sfondo bianco... come è possibile?  o_O
E' possibile risolvere senza definire un xml personalizzato?
grazie, ciao! ;-)

Offline Ricky`

  • Amministratore
  • Utente storico
  • *****
  • Post: 3489
  • Respect: +506
    • Github
    • Google+
    • rciovati
    • Mostra profilo
Re:[facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)
« Risposta #7 il: 28 Maggio 2011, 11:19:17 CEST »
0
Grazie! sono riuscito!
Ora l'unico problema è che ho gli item bianchi su sfondo bianco... come è possibile?  o_O
E' possibile risolvere senza definire un xml personalizzato?
grazie, ciao! ;-)

Crei un SimpleCursorAdapter con un layout personalizzato e glielo passi al Dialog. Niente di trascendentale.

Offline cadupper

  • Utente junior
  • **
  • Post: 81
  • Respect: 0
    • cadupper
    • Mostra profilo
  • Dispositivo Android:
    HTC Magic Tim (32A)
  • Play Store ID:
    cadupper
  • Sistema operativo:
    Ubuntu 10.04
Re:[facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)
« Risposta #8 il: 28 Maggio 2011, 11:25:41 CEST »
0
Lasciando perdere per un momento il problema di prima, ho la necesità di ricavare l'indice _id della mia tabella nel db una volta che ho selezioneto un elemento dal dialog.. il mio codice è questo:
Codice (Java): [Seleziona]
protected Dialog onCreateDialog(int id) {
                Dialog dialog;
                switch (id) {
                case CONFIRM_DIALOG:
                        AlertDialog.Builder builder = new AlertDialog.Builder(this);
                        builder.setTitle("Select the buyer");
                       
                        db.open();
                        c = db.fetchPeopleByEvent(idEve);
                        startManagingCursor(c);
                        adapter = new SimpleCursorAdapter(this, R.layout.row_people, c,
                                        new String[] { AppDB.peoName }, new int[] { R.id.peoName });
                        int count = adapter.getCount();
                        builder.setSingleChoiceItems(adapter, -1,
                                        new DialogInterface.OnClickListener() {
                                                public void onClick(DialogInterface dialog, int item) {
                                                        dialog.dismiss(); // chiudiamo il dialog
                                                       
                                                        idBuyer=???????
                                                       
                                                        Toast.makeText(getApplicationContext(),
                                                                        idBuyer+"", Toast.LENGTH_SHORT).show();
                                                }
                                        });
                        db.close();

                        dialog = builder.create();
                        break;
                default:
                        dialog = null;
                }
                return dialog;
        }

devo cioè ricavare idBuyer che è la colonna _id del mio database. 
Se stampo item mi da 0,1,2,3... insomma l'elemento che ho cliccato, ma visto che prima di inserire gli elementi nell'adapter avevo fatto una selezione
Codice (Java): [Seleziona]
c = db.fetchPeopleByEvent(idEve); ora non so più come fare a tornare indietro... qualche idea?
Grazie, ciao! :-)

Offline salvatore.zagarella

  • Utente normale
  • ***
  • Post: 239
  • Respect: +2
    • Mostra profilo
    • Ieeng Solution
Re:[facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)
« Risposta #9 il: 29 Settembre 2011, 13:20:21 CEST »
0
Scusate ragazzi,
c'è la possibilità di far chiudere una ProgressDialog dopo un certo numero di secondi.. 1,5 per esempio??

Grazie.

Offline DarkPhoinix

  • Utente junior
  • **
  • Post: 133
  • Respect: +1
    • Mostra profilo
  • Dispositivo Android:
    HTC HD2 & Samsung Galaxy SII
  • Sistema operativo:
    LNX
Re:[facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)
« Risposta #10 il: 14 Dicembre 2011, 18:47:08 CET »
0
Grazie maku85!!

maku85++;

Offline DarkPhoinix

  • Utente junior
  • **
  • Post: 133
  • Respect: +1
    • Mostra profilo
  • Dispositivo Android:
    HTC HD2 & Samsung Galaxy SII
  • Sistema operativo:
    LNX
Re:[facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)
« Risposta #11 il: 14 Dicembre 2011, 18:50:49 CET »
0
Scusate ragazzi,
c'è la possibilità di far chiudere una ProgressDialog dopo un certo numero di secondi.. 1,5 per esempio??

Grazie.

Si ma credo sia uno spreco! prova con sleep.



Offline bradipao

  • Moderatore globale
  • Utente storico
  • *****
  • Post: 4043
  • keep it simple
  • Respect: +567
    • Github
    • Google+
    • bradipao
    • Mostra profilo
  • Dispositivo Android:
    Nexus 5
  • Play Store ID:
    Bradipao
  • Sistema operativo:
    W7
Re:[facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)
« Risposta #12 il: 14 Dicembre 2011, 20:47:49 CET »
+1
Scusate ragazzi,
c'è la possibilità di far chiudere una ProgressDialog dopo un certo numero di secondi.. 1,5 per esempio??

Auto-close dialog after a specific time
NON rispondo a domande nei messaggi privati
Bradipao @ Play Store

Offline DarkPhoinix

  • Utente junior
  • **
  • Post: 133
  • Respect: +1
    • Mostra profilo
  • Dispositivo Android:
    HTC HD2 & Samsung Galaxy SII
  • Sistema operativo:
    LNX

Offline marek87

  • Nuovo arrivato
  • *
  • Post: 22
  • Respect: 0
    • Mostra profilo
Re:[facile] Uso dei Dialog (AlertDialog, ProgressDialog e CustomDialog)
« Risposta #14 il: 25 Gennaio 2012, 18:00:45 CET »
0
Salve ragazzi ho un problema. Dovrei inserire un dialog dentro un altro dialog ma non riesco a farlo.
Mi spiego meglio: ho creato un menu, al clic di un icon menu apro un dialog con una lista di variabili. Dopo aver spuntato le variabili e cliccato sul pulsante avanti vorrei aprire un altro dialog.
Qualcuno può aiutarmi? Grazie!!
In allegato lo screenshot della mia applicazione.