¿Qué significa la siguiente excepción? ¿Cómo puedo arreglarlo?

Este es el código:

Toast toast = Toast.makeText(mContext, "Something", Toast.LENGTH_SHORT);

Esta es la excepción:

java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
     at android.os.Handler.<init>(Handler.java:121)
     at android.widget.Toast.<init>(Toast.java:68)
     at android.widget.Toast.makeText(Toast.java:231)

Lo estás llamando desde un hilo de trabajo. Debe llamar Toast.makeText()(y la mayoría de las otras funciones relacionadas con la IU) desde el hilo principal. Podría usar un controlador, por ejemplo.

Consulte Comunicación con el subproceso de interfaz de usuario en la documentación. En una palabra:

// Set this up in the UI thread.

mHandler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(Message message) {
        // This is where you do your work in the UI thread.
        // Your worker tells you in the message what to do.
    }
};

void workerThread() {
    // And this is how you call it from the worker thread:
    Message message = mHandler.obtainMessage(command, parameter);
    message.sendToTarget();
}

Otras opciones:

Puede usar una AsyncTask , que funciona bien para la mayoría de las cosas que se ejecutan en segundo plano. Tiene ganchos a los que puede llamar para indicar el progreso y cuándo está hecho.

También puede usar Activity.runOnUiThread () .

Debe llamar Toast.makeText(...)desde el hilo de la interfaz de usuario:

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

Esto se copia de otra respuesta SO (duplicada) .

ACTUALIZACIÓN - 2016

La mejor alternativa es utilizar RxAndroid(fijaciones específicas para RxJava) para el Pde MVPhacerse cargo fo datos.

Comience por regresar Observablede su método existente.

private Observable<PojoObject> getObservableItems() {
    return Observable.create(subscriber -> {

        for (PojoObject pojoObject: pojoObjects) {
            subscriber.onNext(pojoObject);
        }
        subscriber.onCompleted();
    });
}

Use este Observable como este:

getObservableItems().
subscribeOn(Schedulers.io()).
observeOn(AndroidSchedulers.mainThread()).
subscribe(new Observer<PojoObject> () {
    @Override
    public void onCompleted() {
        // Print Toast on completion
    }

    @Override
    public void onError(Throwable e) {}

    @Override
    public void onNext(PojoObject pojoObject) {
        // Show Progress
    }
});
}

-------------------------------------------------- -------------------------------------------------- ------------------------------

Sé que llego un poco tarde pero aquí va. Básicamente, Android funciona en dos tipos de subprocesos, a saber, subproceso de interfaz de usuario y subproceso de fondo . De acuerdo con la documentación de Android:

No acceda al kit de herramientas de la interfaz de usuario de Android desde fuera del hilo de la interfaz de usuario para solucionar este problema, Android ofrece varias formas de acceder al hilo de la interfaz de usuario desde otros hilos. Aquí hay una lista de métodos que pueden ayudar:

Activity.runOnUiThread(Runnable)  
View.post(Runnable)  
View.postDelayed(Runnable, long)

Ahora hay varios métodos para resolver este problema.

Lo explicaré por ejemplo de código:

runOnUiThread

new Thread()
{
    public void run()
    {
        myactivity.this.runOnUiThread(new Runnable()
        {
            public void run()
            {
                //Do your UI operations like dialog opening or Toast here
            }
        });
    }
}.start();

LOOPER

Clase utilizada para ejecutar un bucle de mensaje para un hilo. Los subprocesos por defecto no tienen un bucle de mensajes asociado con ellos; para crear uno, llame a prepare () en el hilo que va a ejecutar el bucle, y luego bucle () para que procese los mensajes hasta que se detenga.

class LooperThread extends Thread {
    public Handler mHandler;

    public void run() {
        Looper.prepare();

        mHandler = new Handler() {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };

        Looper.loop();
    }
}

AsyncTask

AsyncTask le permite realizar trabajos asincrónicos en su interfaz de usuario. Realiza las operaciones de bloqueo en un subproceso de trabajo y luego publica los resultados en el subproceso de la interfaz de usuario, sin necesidad de que usted mismo maneje los subprocesos y / o controladores.

public void onClick(View v) {
    new CustomTask().execute((Void[])null);
}


private class CustomTask extends AsyncTask<Void, Void, Void> {

    protected Void doInBackground(Void... param) {
        //Do some work
        return null;
    }

    protected void onPostExecute(Void param) {
        //Print Toast or open dialog
    }
}

Manipulador

Un controlador le permite enviar y procesar mensajes y objetos ejecutables asociados con MessageQueue de un hilo.

Message msg = new Message();


new Thread()
{
    public void run()
    {
        msg.arg1=1;
        handler.sendMessage(msg);
    }
}.start();



Handler handler = new Handler(new Handler.Callback() {

    @Override
    public boolean handleMessage(Message msg) {
        if(msg.arg1==1)
        {
            //Print Toast or open dialog        
        }
        return false;
    }
});

Toast.makeText()solo debe llamarse desde el subproceso principal / UI. Looper.getMainLooper () te ayuda a lograrlo:

new Handler(Looper.getMainLooper()).post(new Runnable() {
    @Override
    public void run() {
        Toast toast = Toast.makeText(mContext, "Something", Toast.LENGTH_SHORT);
    }
});

Una ventaja de este método es que puede usarlo sin Actividad o Contexto.

Intente esto, cuando vea runtimeException debido a que Looper no está preparado antes del controlador.

Handler handler = new Handler(Looper.getMainLooper()); 

handler.postDelayed(new Runnable() {
  @Override
  public void run() {
  // Run your task here
  }
}, 1000 );

Me encontré con el mismo problema, y ​​así es como lo solucioné:

private final class UIHandler extends Handler
{
    public static final int DISPLAY_UI_TOAST = 0;
    public static final int DISPLAY_UI_DIALOG = 1;

    public UIHandler(Looper looper)
    {
        super(looper);
    }

    @Override
    public void handleMessage(Message msg)
    {
        switch(msg.what)
        {
        case UIHandler.DISPLAY_UI_TOAST:
        {
            Context context = getApplicationContext();
            Toast t = Toast.makeText(context, (String)msg.obj, Toast.LENGTH_LONG);
            t.show();
        }
        case UIHandler.DISPLAY_UI_DIALOG:
            //TBD
        default:
            break;
        }
    }
}

protected void handleUIRequest(String message)
{
    Message msg = uiHandler.obtainMessage(UIHandler.DISPLAY_UI_TOAST);
    msg.obj = message;
    uiHandler.sendMessage(msg);
}

Para crear el UIHandler, deberá realizar lo siguiente:

    HandlerThread uiThread = new HandlerThread("UIHandler");
    uiThread.start();
    uiHandler = new UIHandler((HandlerThread) uiThread.getLooper());

Espero que esto ayude.

Motivo de un error:

Los subprocesos de trabajo están destinados a realizar tareas en segundo plano y no puede mostrar nada en la interfaz de usuario dentro de un subproceso de trabajo a menos que llame a un método como runOnUiThread . Si intenta mostrar algo en el hilo de la interfaz de usuario sin llamar a runOnUiThread, habrá un java.lang.RuntimeException.

Entonces, si está en un hilo de trabajador activitypero llamando Toast.makeText(), haga esto:

runOnUiThread(new Runnable() 
{
   public void run() 
   {
      Toast toast = Toast.makeText(getApplicationContext(), "Something", Toast.LENGTH_SHORT).show();    
   }
}); 

El código anterior asegura que está mostrando el mensaje Toast en un método UI threadya que lo está llamando dentro runOnUiThread. Entonces no más java.lang.RuntimeException.

eso fue lo que hice.

new Handler(Looper.getMainLooper()).post(new Runnable() {
    @Override
    public void run() {
        Toast(...);
    }
});

Los componentes visuales están "bloqueados" a los cambios desde hilos externos. Entonces, dado que el brindis muestra cosas en la pantalla principal administradas por el hilo principal, debe ejecutar este código en ese hilo. Espero que ayude:)

Recibí este error hasta que hice lo siguiente.

public void somethingHappened(final Context context)
{
    Handler handler = new Handler(Looper.getMainLooper());
    handler.post(
        new Runnable()
        {
            @Override
            public void run()
            {
                Toast.makeText(context, "Something happened.", Toast.LENGTH_SHORT).show();
            }
        }
    );
}

Y convirtió esto en una clase singleton:

public enum Toaster {
    INSTANCE;

    private final Handler handler = new Handler(Looper.getMainLooper());

    public void postMessage(final String message) {
        handler.post(
            new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(ApplicationHolder.INSTANCE.getCustomApplication(), message, Toast.LENGTH_SHORT)
                        .show();
                }
            }
        );
    }

}

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

Maravillosa solución de Kotlin:

runOnUiThread {
    // Add your ui thread code here
}

Esto se debe a que Toast.makeText () está llamando desde un subproceso de trabajo. Debe llamarse desde el hilo principal de la interfaz de usuario como este

runOnUiThread(new Runnable() {
      public void run() {
        Toast toast = Toast.makeText(mContext, "Something", Toast.LENGTH_SHORT);
      }
 });

La respuesta de ChicoBird funcionó para mí. El único cambio que hice fue en la creación del UIHandler donde tuve que hacer

HandlerThread uiThread = new HandlerThread("UIHandler");

Eclipse se negó a aceptar cualquier otra cosa. Tiene sentido, supongo.

Además, uiHandleres claramente una clase global definida en alguna parte. Todavía no pretendo entender cómo Android está haciendo esto y qué está sucediendo, pero me alegro de que funcione. Ahora procederé a estudiarlo y veré si puedo entender qué está haciendo Android y por qué uno tiene que pasar por todos estos aros y bucles. Gracias por la ayuda ChicoBird.

primera llamada Looper.prepare()y luego llamada Toast.makeText().show()última llamada Looper.loop()como:

Looper.prepare() // to be able to make toast
Toast.makeText(context, "not connected", Toast.LENGTH_LONG).show()
Looper.loop()

Para usuarios de Rxjava y RxAndroid:

public static void shortToast(String msg) {
    Observable.just(msg)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(message -> {
                Toast.makeText(App.getInstance(), message, Toast.LENGTH_SHORT).show();
            });
}

Me encontraba con el mismo problema cuando mis devoluciones de llamada intentaban mostrar un diálogo.

Lo resolví con métodos dedicados en la Actividad, en el nivel de miembro de la instancia de Actividad , que usanrunOnUiThread(..)

public void showAuthProgressDialog() {
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            mAuthProgressDialog = DialogUtil.getVisibleProgressDialog(SignInActivity.this, "Loading ...");
        }
    });
}

public void dismissAuthProgressDialog() {
    runOnUiThread(new Runnable() {
        @Override
        public void run() {
            if (mAuthProgressDialog == null || ! mAuthProgressDialog.isShowing()) {
                return;
            }
            mAuthProgressDialog.dismiss();
        }
    });
}

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

Ahora handler2 usará un hilo diferente para manejar los mensajes que el hilo principal.

Para mostrar un cuadro de diálogo o una tostadora en un hilo, la forma más concisa es usar el objeto Actividad.

Por ejemplo:

new Thread(new Runnable() {
    @Override
    public void run() {
        myActivity.runOnUiThread(new Runnable() {
            public void run() {
                myActivity.this.processingWaitDialog = new ProgressDialog(myActivity.this.getContext());
                myActivity.this.processingWaitDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
                myActivity.this.processingWaitDialog.setMessage("abc");
                myActivity.this.processingWaitDialog.setIndeterminate(true);
                myActivity.this.processingWaitDialog.show();
            }
        });
        expenseClassify.serverPost(
                new AsyncOperationCallback() {
                    public void operationCompleted(Object sender) {
                        myActivity.runOnUiThread(new Runnable() {
                            public void run() {
                                if (myActivity.this.processingWaitDialog != null 
                                        && myActivity.this.processingWaitDialog.isShowing()) {
                                    myActivity.this.processingWaitDialog.dismiss();
                                    myActivity.this.processingWaitDialog = null;
                                }
                            }
                        }); // .runOnUiThread(new Runnable()
...

Toast, AlertDialogs necesita ejecutarse en el hilo de la interfaz de usuario, puede usar Asynctask para usarlos correctamente en el desarrollo de Android. Pero en algunos casos necesitamos personalizar los tiempos de espera, por lo que usamos hilos , pero en los hilos no podemos usar Toast, Alertdialogs como usamos en AsyncTask.So que necesita separar Handler para aquellos emergente.

public void onSigned() {
    Thread thread = new Thread(){
        @Override
        public void run() {
            try{
                sleep(3000);
                Message message = new Message();
                message.what = 2;
                handler.sendMessage(message);
            } catch (Exception e){
                e.printStackTrace();
            }
        }
    };
    thread.start();
}

en el ejemplo anterior, quiero dormir mi hilo en 3 segundos y después quiero mostrar un mensaje Toast, para eso en su controlador de implementación de hilo principal .

handler = new Handler() {
       public void handleMessage(Message msg) {
           switch(msg.what){
              case 1:
              Toast.makeText(getActivity(),"cool",Toast.LENGTH_SHORT).show();
              break;
           }
           super.handleMessage(msg);
       }
};

Usé el caso de cambio aquí, porque si necesita mostrar un mensaje diferente de la misma manera, puede usar el caso de cambio dentro de la clase Handler ... espero que esto lo ayude

Esto generalmente ocurre cuando se llama a algo en el hilo principal desde cualquier hilo de fondo. Veamos un ejemplo, por ejemplo.

private class MyTask extends AsyncTask<Void, Void, Void> {


@Override
protected Void doInBackground(Void... voids) {
        textView.setText("Any Text");
        return null;
    }
}

En el ejemplo anterior, estamos configurando texto en la vista de texto que se encuentra en el hilo principal de la interfaz de usuario del método doInBackground (), que opera solo en un hilo de trabajo.

Tuve el mismo problema y lo solucioné simplemente poniendo Toast en la función de anulación onPostExecute () de Asynctask <> y funcionó.

uso el siguiente código para mostrar el mensaje del "contexto" del hilo principal,

@FunctionalInterface
public interface IShowMessage {
    Context getContext();

    default void showMessage(String message) {
        final Thread mThread = new Thread() {
            @Override
            public void run() {
                try {
                    Looper.prepare();
                    Toast.makeText(getContext(), message, Toast.LENGTH_LONG).show();
                    Looper.loop();
                } catch (Exception error) {
                    error.printStackTrace();
                    Log.e("IShowMessage", error.getMessage());
                }
            }
        };
        mThread.start();
    }
}

luego use como lo siguiente:

class myClass implements IShowMessage{

  showMessage("your message!");
 @Override
    public Context getContext() {
        return getApplicationContext();
    }
}