Android: attendere l'input dell'utente dalla window di dialogo?

Vorrei implementare un metodo che visualizzi una window di dialogo, attende fino alla distriggerszione della window di dialogo e restituisce un risultato a seconda del contenuto della window di dialogo. È ansible?

public String getUserInput() { //do something to show dialog String input = //get input from dialog return input; } 

Sto realmente cercando di implementare un'interface con metodo "public String getUserInput ()", in cui la restituita String deve essere recuperata tramite dialogo. Questo è facilmente fatto in java, sembra imansible in android?

  • Come mostrare banner pubblicitari in modo intermittente in gridview
  • Cache di disegno Android
  • android: non è in grado di trovare la posizione utilizzando FusedLocationApi anche dopo aver abilitato il GPS
  • Preparazione di MediaPlayer non rioutput
  • MpAndroidChart HorizontalBarChart Personalizza l'etichetta
  • Android: Notifica non funziona a 2.3.6 (galassia Samsung y)
  • EDIT: Inserimento di un codice di esempio come richiesto nel commento

    getInput() deve essere chiamato da un thread di background (lo chiamo da un AsynchTask). getInput () visualizza una window di dialogo e chiama attesa. Quando il button OK viene premuto nella window di dialogo, la window di dialogo imposta l'input utente in una variabile membro e le chiamate notificano. Quando viene notificato, getInput () continua e restituisce la variabile membro.

     String m_Input; public synchronized String getInput() { runOnUiThread(new Runnable() { @Override public void run() { AlertDialog.Builder alert = new AlertDialog.Builder(context); //customize alert dialog to allow desired input alert.setPositiveButton("Ok", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int whichButton) { m_Input = alert.getCustomInput(); notify(); } }); alert.show(); } }); try { wait(); } catch (InterruptedException e) { } return m_Input; } 

  • Html.fromHtml deprecato in Android N
  • La libreria di scansione a barre ZBAR non funziona quando si utilizza la versione 23 di sdk di destinazione in gradle
  • L'icona dell'elemento del cassetto di navigazione non mostra il colore originale
  • Firebase Android onAuthStateChanged () fuoco due volte dopo signInWithEmailAndPassword ()
  • Come inserire valori doppio e float a sqlite?
  • Imansible trovare il codice categoria Builder
  • 6 Solutions collect form web for “Android: attendere l'input dell'utente dalla window di dialogo?”

    È ansible?

    No. Non esiste un model di block UI in Android. Tutto è asincrono.

    AGGIORNARE

    In risposta a alcuni dei tuoi commenti sulla domanda stessa, non puoi visualizzare un interface utente da un thread di background. Come ho scritto in questa risposta, non esiste un model di block UI in Android. Basta inserire il codice nel gestore del button per la window di dialogo che si desidera eseguire quando viene accettata la window di dialogo, ad esempio in questo progetto di esempio .

    Il modo giusto per farlo è un model di programma guidato da events, cioè "non chiamarci, ti chiameremo".

    Nella programmazione semplice della modalità console, il codice tende a call funzioni di block delle entrate che non tornano finché non si ottiene un valore.

    Molti ambienti di programmazione gui funzionano in modo diverso – il codice non funziona normalmente, ma viene chiamato dal sistema operativo / window manager quando si verifica qualcosa di potenziale interesse. Tu fai qualcosa in risposta a questo e ritorni prontamente – se non lo fai, non puoi essere avvisato di altro perché il sistema operativo non ha modo di contattarti finché non ritorni. (Rispetto a win32, è come se il ciclo di messaggi sia implementato da Android e si arriva solo a scrivere il resto del codice che chiama loop di messaggi con events – se non torni prontamente, il ciclo del messaggio appende)

    Di conseguenza, è necessario ripensare al concetto di stream di programma. Invece di scrivere un elenco di cose da fare come una semplice serie di affermazioni, pensaci come una sequenza di azioni che dipendono l'una dall'altra e per l'input. Ricorda quale azione è attualmente in una variabile di stato. Quando viene chiamato con un evento come l'input utente, vedere se tale evento significa che è ora ansible passare al passaggio successivo e se è così aggiornare la variabile di stato prima di ritornare prontamente al sistema operativo per poter ricevere il prossimo evento. Se l'evento non era quello di cui hai bisogno, torni subito senza aggiornare il tuo stato.

    Se questo model non funziona per voi, è ansible scrivere un thread di background della logica di programma che esegue come un'applicazione in modalità console utilizzando l'input di block. Ma le tue funzioni di input veramente aspettano una bandiera o qualcosa da notificare che l'input è disponibile. Quindi sul tuo thread dell'interface utente in cui Android distribuisce events, aggiorna la bandiera e tornerà prontamente. Il thread di background vede che la bandiera è cambiata per indicare che i dati sono stati forniti e continua l'esecuzione. (Qualcosa di simile ad un emulatore di terminal android prende questo in un estremo, in cui il componente di background è in realtà un altro process – una modalità console linux uno e ottiene il suo ingresso usando il potenzialmente block di I / O dai tubi. inserisce i caratteri nel pipe stdin e li estrae dal pipe di stdout per visualizzare sullo schermo.)

    Grazie per tutte le risposte, sono stato in grado di risolvere questo problema utilizzando un thread di background insieme ad un wait () e notify (). Riconosco che questa non è la più grande idea del paradigma dato, ma era necessario conformarsi a una biblioteca con cui sto lavorando.

    Qualcosa di simile avrebbe fatto

     /** * */ import android.app.Activity; import android.content.Intent; import android.os.Bundle; import android.view.View; import android.view.WindowManager; import android.view.View.OnClickListener; import android.widget.Button; import android.widget.EditText; /** * @author */ public class TextEntryActivity extends Activity { private EditText et; /* * (non-Javadoc) * @see android.app.Activity#onCreate(android.os.Bundle) */ @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_text_entry); getWindow().setFlags(WindowManager.LayoutParams.FLAG_BLUR_BEHIND, WindowManager.LayoutParams.FLAG_BLUR_BEHIND); // title try { String s = getIntent().getExtras().getString("title"); if (s.length() > 0) { this.setTitle(s); } } catch (Exception e) { } // value try { et = ((EditText) findViewById(R.id.txtValue)); et.setText(getIntent().getExtras().getString("value")); } catch (Exception e) { } // button ((Button) findViewById(R.id.btnDone)).setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { executeDone(); } }); } /* (non-Javadoc) * @see android.app.Activity#onBackPressed() */ @Override public void onBackPressed() { executeDone(); super.onBackPressed(); } /** * */ private void executeDone() { Intent resultIntent = new Intent(); resultIntent.putExtra("value", TextEntryActivity.this.et.getText().toString()); setResult(Activity.RESULT_OK, resultIntent); finish(); } } 

    Il lancio è:

     public void launchPreferedNameEdit() { Intent foo = new Intent(this, TextEntryActivity.class); foo.putExtra("value", objItem.getPreferedNickname()); this.startActivityForResult(foo, EDIT_PREFERED_NAME); } 

    Ottieni il risultato utilizzando

     protected void onActivityResult(int requestCode, int resultCode, Intent data) { switch (requestCode) { case EDIT_PREFERED_NAME: try { String value = data.getStringExtra("value"); if (value != null && value.length() > 0) { } } catch (Exception e) { } break; default: break; } } 

    CASE: I miei dati erano pronti per essere processi dopo un evento di listener cambiamento di preferenza e ho dovuto aggiungere una string interrogata dall'utente. Non sembra ansible aprire una window di avviso quando il menu delle opzioni è aperto … quindi ho dovuto aspettare. Ho gettato l'object mezzo completato nell'attività successiva nel stream di lavoro e impostato il suo onResume () per verificare se il suo segnaposto era null e in quel caso ho aperto la window di dialogo e ho finito l'object * nel gestore dei pulsanti della window di dialogo * .

    Dal momento che questo è il mio primo post non posso votare per la risposta corretta data in precedenza, ma voglio salvare qualcun altro correre in questo il tempo e l'eleganza di soluzioni less corrette. La window di dialogo è il luogo.

    Si può pensare in termini di macchina statale where, se si richiede inizialmente l'input utente di prima volta, è ansible impostare una bandiera per indicare "l'input dell'utente necessario" o qualsiasi altra cosa. Quindi, al momento dell'elaborazione di un evento, verificherai che la bandiera e se impostata si avvia una window di dialogo come l'unica azione per l'evento e distriggers la bandiera. Quindi dal gestore di events di dialogo dopo la gestione dell'ingresso utente è ansible call il codice normalmente destinato al caso in cui non è necessaria una window di dialogo.

    L'Android è un fan Android di Google, tutto su telefoni Android, Android Wear, Android Dev e applicazioni Android Games e così via.