O que significa a seguinte exceção; como posso consertar isso?

Este é o código:

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

Esta é a exceção:

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)

Você está chamando isso de um thread de trabalho. Você precisa chamar Toast.makeText()(e a maioria das outras funções que lidam com a interface do usuário) de dentro do thread principal. Você pode usar um manipulador, por exemplo.

Consulte Comunicação com o thread da interface do usuário na documentação. Em poucas palavras:

// 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();
}

Outras opções:

Você pode usar um AsyncTask , que funciona bem para a maioria das coisas em execução em segundo plano. Tem ganchos que você pode chamar para indicar o progresso e quando terminar.

Você também pode usar Activity.runOnUiThread () .

Você precisa chamar Toast.makeText(...)do thread da interface do usuário:

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

Isso é copiado e colado de outra resposta do SO (duplicada) .

ATUALIZAÇÃO - 2016

A melhor alternativa é usar RxAndroid(ligações específicas para RxJava) para o Pno MVPpara assumir o comando fo dados.

Comece retornando Observabledo seu método existente.

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

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

Use este Observável assim -

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
    }
});
}

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

Eu sei que estou um pouco atrasado, mas aqui vai. O Android basicamente funciona em dois tipos de encadeamentos, ou seja, encadeamento da interface do usuário e encadeamento em segundo plano . De acordo com a documentação do Android -

Não acesse o kit de ferramentas da interface do usuário do Android de fora do thread da interface do usuário para corrigir esse problema, o Android oferece várias maneiras de acessar o thread da interface do usuário a partir de outros threads. Aqui está uma lista de métodos que podem ajudar:

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

Agora, existem vários métodos para resolver esse problema.

Vou explicar isso por exemplo 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

Classe usada para executar um loop de mensagem para um encadeamento. Os encadeamentos por padrão não têm um loop de mensagem associado a eles; para criar um, chame prepare () no thread que deve executar o loop e, em seguida, loop () para que ele processe as mensagens até que o loop seja interrompido.

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

O AsyncTask permite que você execute um trabalho assíncrono na interface do usuário. Ele executa as operações de bloqueio em um encadeamento de trabalho e, em seguida, publica os resultados no encadeamento da interface do usuário, sem exigir que você lide com os encadeamentos e / ou manipuladores.

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
    }
}

Handler

Um manipulador permite enviar e processar objetos Message e Runnable associados ao MessageQueue de um thread.

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()deve ser chamado apenas do thread Principal / UI. Looper.getMainLooper () ajuda você a alcançá-lo:

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

Uma vantagem desse método é que você pode usá-lo sem Atividade ou Contexto.

Tente isso quando vir runtimeException devido ao Looper não preparado antes do manipulador.

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

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

Corri para o mesmo problema, e aqui está como corrigi-lo:

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 criar o UIHandler, você precisará executar o seguinte:

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

Espero que isto ajude.

Razão para um erro:

Os encadeamentos de trabalho destinam-se à execução de tarefas em segundo plano e você não pode mostrar nada na interface do usuário em um encadeamento de trabalho, a menos que chame um método como runOnUiThread . Se você tentar mostrar algo no thread da interface do usuário sem chamar runOnUiThread, haverá umjava.lang.RuntimeException .

Portanto, se você estiver em uma activitychamada, mas Toast.makeText()do segmento de trabalho, faça o seguinte:

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

O código acima garante que você esteja mostrando a mensagem Toast em um método UI threaddesde que a está chamando dentro runOnUiThread. Então não mais java.lang.RuntimeException.

Isso é o que eu fiz.

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

Os componentes visuais estão "bloqueados" para alterações de threads externos. Portanto, como o brinde mostra coisas na tela principal que são gerenciadas pelo thread principal, você precisa executar esse código nesse segmento. Espero que ajude:)

Eu estava recebendo esse erro até fazer o seguinte.

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();
            }
        }
    );
}

E transformou isso em uma classe 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();
            }
        });

Maravilhosa solução Kotlin:

runOnUiThread {
    // Add your ui thread code here
}

Isso ocorre porque Toast.makeText () está chamando de um thread de trabalho. Deve ser chamada do thread principal da interface do usuário como este

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

A resposta de ChicoBird funcionou para mim. A única alteração que fiz foi na criação do UIHandler, onde eu tive que fazer

HandlerThread uiThread = new HandlerThread("UIHandler");

Eclipse se recusou a aceitar qualquer outra coisa. Faz sentido, suponho.

Também uiHandleré claramente uma classe global definida em algum lugar. Ainda não pretendo entender como o Android está fazendo isso e o que está acontecendo, mas estou feliz que funcione. Agora vou estudá-lo e ver se consigo entender o que o Android está fazendo e por que é preciso passar por todos esses ciclos. Obrigado pela ajuda ChicoBird.

primeira Looper.prepare()e depois a Toast.makeText().show()última, Looper.loop()como:

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

Para usuários Rxjava e RxAndroid:

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

Eu estava com o mesmo problema quando meus retornos de chamada tentavam mostrar uma caixa de diálogo.

Eu o resolvi com métodos dedicados na Activity - no nível de membro da instância Activity - que usamrunOnUiThread(..)

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());

Agora handler2 usará um Thread diferente para manipular as mensagens que o Thread principal.

Para exibir uma caixa de diálogo ou uma torradeira em um thread, a maneira mais concisa é usar o objeto Activity.

Por exemplo:

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()
...

Brinde, AlertDialogs precisa ser executado no segmento interface do usuário, você pode usar AsyncTask usá-los corretamente no android development.but alguns casos precisamos personalizar os pedidos de tempo, por isso usamos Threads , mas em tópicos que não podemos usar brinde, Alertdialogs como nós usando no AsyncTask.So, precisamos de Handler separado para pop-up.

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();
}

no exemplo acima, quero dormir meu segmento em 3seg e depois quero mostrar uma mensagem do Toast, para isso no seu manipulador de implementos mainthread .

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);
       }
};

Usei switch case aqui, porque se você precisar mostrar uma mensagem diferente da mesma maneira, poderá usar switch case na classe Handler ... espero que isso ajude você

Isso geralmente acontece quando algo no thread principal é chamado de qualquer thread em segundo plano. Vamos ver um exemplo, por exemplo.

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


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

No exemplo acima, estamos definindo texto no textview que está no thread principal da interface do usuário do método doInBackground (), que opera apenas em um thread de trabalho.

Eu tive o mesmo problema e o corrigi simplesmente colocando a Toast na função de substituição onPostExecute () do Asynctask <> e funcionou.

eu uso o código a seguir para mostrar a mensagem do segmento não principal "contexto",

@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();
    }
}

em seguida, use o seguinte:

class myClass implements IShowMessage{

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