Come si visualizza un avviso popup da un thread in background su Android?

Come posso visualizzare i messaggi Toast da un thread?

Puoi farlo chiamando un Activity's runOnUiThreadmetodo dal tuo thread:

activity.runOnUiThread(new Runnable() {
    public void run() {
        Toast.makeText(activity, "Hello", Toast.LENGTH_SHORT).show();
    }
});

Mi piace avere un metodo nella mia attività chiamato showToastche posso chiamare da qualsiasi luogo ...

public void showToast(final String toast)
{
    runOnUiThread(() -> Toast.makeText(MyActivity.this, toast, Toast.LENGTH_SHORT).show());
}

Quindi lo chiamo più spesso dall'interno MyActivitysu qualsiasi thread come questo ...

showToast(getString(R.string.MyMessage));

Questo è simile ad altre risposte, tuttavia aggiornato per le nuove API disponibili e molto più pulito. Inoltre, non presume che ti trovi in ​​un contesto di attività.

public class MyService extends AnyContextSubclass {

    public void postToastMessage(final String message) {
        Handler handler = new Handler(Looper.getMainLooper());

        handler.post(new Runnable() {

            @Override
            public void run() {
                Toast.makeText(getContext(), message, Toast.LENGTH_LONG).show();
            }
        });
    }
}

Un approccio che funziona praticamente da qualsiasi luogo, anche da luoghi in cui non hai un Activityo View, è quello di prendere un Handleral thread principale e mostrare il brindisi:

public void toast(final Context context, final String text) {
  Handler handler = new Handler(Looper.getMainLooper());
  handler.post(new Runnable() {
    public void run() {
      Toast.makeText(context, text, Toast.LENGTH_LONG).show();
    }
  });
}

Il vantaggio di questo approccio è che funziona con qualsiasi Context, inclusi Servicee Application.

Come questo o questo , con un Runnableche mostra il file Toast. Vale a dire,

Activity activity = // reference to an Activity
// or
View view = // reference to a View

activity.runOnUiThread(new Runnable() {
    @Override
    public void run() {
        showToast(activity);
    }
});
// or
view.post(new Runnable() {
    @Override
    public void run() {
        showToast(view.getContext());
    }
});

private void showToast(Context ctx) {
    Toast.makeText(ctx, "Hi!", Toast.LENGTH_SHORT).show();
}

A volte, devi inviare un messaggio da un altro Threadal thread dell'interfaccia utente. Questo tipo di scenario si verifica quando non è possibile eseguire operazioni di rete / I / O sul thread dell'interfaccia utente.

L'esempio seguente gestisce quello scenario.

1. Hai il thread dell'interfaccia utente
2. È necessario avviare l'operazione di I / O e quindi non è possibile eseguire Runnableil thread dell'interfaccia utente. Quindi pubblica il tuo Runnableal gestore suHandlerThread
3. Ottieni il risultato da Runnablee invialo di nuovo al thread dell'interfaccia utente e mostra un Toastmessaggio.

Soluzione:

1. Crea un HandlerThread e avviarlo
2. Crea un gestore con Looper da HandlerThread:requestHandler
3. Crea un gestore con Looper dal thread principale: responseHandlere sovrascrivi il handleMessagemetodo
4. postun RunnablecompitorequestHandler
5. All'interno Runnablecompito, chiamare sendMessageilresponseHandler
6. Questa sendMessageinvocazione del risultato di handleMessagein responseHandler.
7. Ottieni attributi da Messageed elaboralo, aggiorna l'interfaccia utente

Codice di esempio:

    /* Handler thread */

    HandlerThread handlerThread = new HandlerThread("HandlerThread");
    handlerThread.start();
    Handler requestHandler = new Handler(handlerThread.getLooper());

    final Handler responseHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            //txtView.setText((String) msg.obj);
            Toast.makeText(MainActivity.this,
                    "Runnable on HandlerThread is completed and got result:"+(String)msg.obj,
                    Toast.LENGTH_LONG)
                    .show();
        }
    };

    for ( int i=0; i<5; i++) {
        Runnable myRunnable = new Runnable() {
            @Override
            public void run() {
                try {

                    /* Add your business logic here and construct the 
                       Messgae which should be handled in UI thread. For 
                       example sake, just sending a simple Text here*/

                    String text = "" + (++rId);
                    Message msg = new Message();

                    msg.obj = text.toString();
                    responseHandler.sendMessage(msg);
                    System.out.println(text.toString());

                } catch (Exception err) {
                    err.printStackTrace();
                }
            }
        };
        requestHandler.post(myRunnable);
    }

Articoli utili:

handlerthreads-e-perché-si-deve-essere-utilizzando-li-in-your-android-apps

Android-crochet-gestore-handlerthread-i

1. Ottieni l'istanza del gestore thread dell'interfaccia utente e usa handler.sendMessage();
2. post()Metodo di chiamatahandler.post();
3. runOnUiThread()
4. view.post()

È possibile utilizzare Looperper inviare un Toastmessaggio. Passare attraverso questo collegamento per maggiori dettagli.

public void showToastInThread(final Context context,final String str){
    Looper.prepare();
    MessageQueue queue = Looper.myQueue();
    queue.addIdleHandler(new IdleHandler() {
         int mReqCount = 0;

         @Override
         public boolean queueIdle() {
             if (++mReqCount == 2) {
                  Looper.myLooper().quit();
                  return false;
             } else
                  return true;
         }
    });
    Toast.makeText(context, str,Toast.LENGTH_LONG).show();      
    Looper.loop();
}

ed è chiamato nel tuo thread. Il contesto potrebbe derivare Activity.getContext()dal fatto che Activitydevi mostrare il brindisi.

Ho creato questo approccio basato sulla risposta di mjaggard:

public static void toastAnywhere(final String text) {
    Handler handler = new Handler(Looper.getMainLooper());
    handler.post(new Runnable() {
        public void run() {
            Toast.makeText(SuperApplication.getInstance().getApplicationContext(), text, 
                    Toast.LENGTH_LONG).show();
        }
    });
}

Ha funzionato bene per me.

Ho riscontrato lo stesso problema ：

E/AndroidRuntime: FATAL EXCEPTION: Thread-4
              Process: com.example.languoguang.welcomeapp, PID: 4724
              java.lang.RuntimeException: Can't toast on a thread that has not called Looper.prepare()
                  at android.widget.Toast$TN.<init>(Toast.java:393)
                  at android.widget.Toast.<init>(Toast.java:117)
                  at android.widget.Toast.makeText(Toast.java:280)
                  at android.widget.Toast.makeText(Toast.java:270)
                  at com.example.languoguang.welcomeapp.MainActivity$1.run(MainActivity.java:51)
                  at java.lang.Thread.run(Thread.java:764)
I/Process: Sending signal. PID: 4724 SIG: 9
Application terminated.

Prima: funzione onCreate

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        Toast.makeText(getBaseContext(), "Thread", Toast.LENGTH_LONG).show();
    }
});
thread.start();

Dopo: funzione onCreate

runOnUiThread(new Runnable() {
    @Override
    public void run() {
        Toast.makeText(getBaseContext(), "Thread", Toast.LENGTH_LONG).show();
    }
});

ha funzionato.