Executando código no thread principal de outro thread

Em um serviço Android, criei thread (s) para executar alguma tarefa em segundo plano.

Eu tenho uma situação em que um thread precisa postar determinada tarefa na fila de mensagens do thread principal, por exemplo: a Runnable.

Existe uma maneira de obter Handlerdo segmento principal e pós Message/ Runnablea ele do meu outro segmento?

Obrigado,

NOTA: Esta resposta recebeu tanta atenção que preciso atualizá-la. Desde que a resposta original foi postada, o comentário de @dzeikei recebeu quase tanta atenção quanto a resposta original. Então, aqui estão duas soluções possíveis:

1. Se o encadeamento em segundo plano tiver uma referência a um Contextobjeto:

Verifique se os threads de trabalho em segundo plano têm acesso a um objeto de Contexto (pode ser o contexto de Aplicativo ou o contexto de Serviço). Em seguida, basta fazer isso no thread de trabalho em segundo plano:

// Get a handler that can be used to post to the main thread
Handler mainHandler = new Handler(context.getMainLooper());

Runnable myRunnable = new Runnable() {
    @Override 
    public void run() {....} // This is your code
};
mainHandler.post(myRunnable);

2. Se o encadeamento em segundo plano não tiver (ou precisar) de um Contextobjeto

(sugerido por @dzeikei):

// Get a handler that can be used to post to the main thread
Handler mainHandler = new Handler(Looper.getMainLooper());

Runnable myRunnable = new Runnable() {
    @Override 
    public void run() {....} // This is your code
};
mainHandler.post(myRunnable);

Como um comentarista abaixo apontou corretamente, essa não é uma solução geral para serviços, apenas para threads iniciados a partir de sua atividade (um serviço pode ser esse segmento, mas nem todos). Sobre o tópico complicado da comunicação de atividade de serviço, leia toda a seção Serviços do documento oficial - é complexo, portanto vale a pena entender o básico: http://developer.android.com/guide/components/services.html #Notifications

O método abaixo pode funcionar nos casos mais simples.

Se eu entendi corretamente, você precisa de algum código para ser executado no thread da GUI do aplicativo (não consigo pensar em nada mais chamado thread "principal"). Para isso, existe um método em Activity:

someActivity.runOnUiThread(new Runnable() {
        @Override
        public void run() {
           //Your code to run in GUI thread here
        }//public void run() {
});

Doc: http://developer.android.com/reference/android/app/Activity.html#runOnUiThread%28java.lang.Runnable%29

Espero que seja isso que você está procurando.

Existe outra maneira simples, se você não tiver acesso ao contexto.

1) Crie um manipulador a partir do looper principal:

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

2) Implemente uma interface Runnable:

Runnable runnable = new Runnable() { // your code here }

3) Publique o seu Runnable no uiHandler:

uiHandler.post(runnable);

Isso é tudo ;-) Divirta-se com os tópicos, mas não se esqueça de sincronizá-los.

Se você executar código em um encadeamento, por exemplo, adiando alguma ação, precisará invocar a runOnUiThreadpartir do contexto. Por exemplo, se seu código estiver dentro da MainActivityclasse, use o seguinte:

MainActivity.this.runOnUiThread(new Runnable() {
    @Override
    public void run() {
        myAction();
    }
});

Se o seu método puder ser chamado a partir do main (thread da UI) ou de outros threads, você precisará de uma verificação como:

public void myMethod() {
   if( Looper.myLooper() == Looper.getMainLooper() ) {
       myAction();
   }
   else {

}

Um bloco de código condensado é o seguinte:

   new Handler(Looper.getMainLooper()).post(new Runnable() {
       @Override
       public void run() {
           // things to do on the main thread
       }
   });

Isso não envolve passar a referência de atividade ou a referência de aplicativo.

Equivalente de Kotlin:

    Handler(Looper.getMainLooper()).post(Runnable {
        // things to do on the main thread
    })

Versões do Kotlin

Quando você estiver em uma atividade , use

runOnUiThread {
    //code that runs in main
}

Quando você tem um contexto de atividade , o mContext então usa

mContext.runOnUiThread {
    //code that runs in main
}

Quando você estiver em algum lugar onde não há contexto disponível , use

Handler(Looper.getMainLooper()).post {  
    //code that runs in main
}

A maneira mais simples, especialmente se você não tiver um contexto, se estiver usando o RxAndroid, poderá:

AndroidSchedulers.mainThread().scheduleDirect {
    runCodeHere()
}

Código Kotlin mais preciso usando manipulador:

Handler(Looper.getMainLooper()).post {  
 // your codes here run on main Thread
 }

Um método que posso pensar é o seguinte:

1) Deixe a interface do usuário vincular ao serviço.
2) Exponha um método como o abaixo, Binderque registra seu Handler:

public void registerHandler(Handler handler) {
    mHandler = handler;
}

3) No thread da interface do usuário, chame o método acima após a ligação ao serviço:

mBinder.registerHandler(new Handler());

4) Use o manipulador no encadeamento do serviço para postar sua tarefa:

mHandler.post(runnable);

HandlerThread é a melhor opção para threads Java normais no Android.

1. Crie um HandlerThread e inicie-o
2. Criar um manipulador com Looper de HandlerThread:requestHandler
3. postuma Runnabletarefa emrequestHandler

Comunicação com o Thread da UI de HandlerThread

1. Crie um método Handlerwith Looperpara main: responseHandlere substituahandleMessage
2. Dentro Runnabletarefa de outra Thread ( HandlerThreadneste caso), chamada sendMessageemresponseHandler
3. A sendMessagechamada deste resultado de handleMessagein responseHandler.
4. Obter atributos Messagee processá-lo, atualizar a interface do usuário

Exemplo : atualização TextViewcom dados recebidos de um serviço da web. Como o serviço da web deve ser chamado em um segmento que não seja da interface do usuário, criado HandlerThreadpara a Operação de Rede. Depois de obter o conteúdo do serviço da Web, envie uma mensagem para o manipulador de thread principal (UI Thread) e Handlerele manipulará a mensagem e atualizará a UI.

Código de amostra:

HandlerThread handlerThread = new HandlerThread("NetworkOperation");
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);
    }
};

Runnable myRunnable = new Runnable() {
    @Override
    public void run() {
        try {
            Log.d("Runnable", "Before IO call");
            URL page = new URL("http://www.your_web_site.com/fetchData.jsp");
            StringBuffer text = new StringBuffer();
            HttpURLConnection conn = (HttpURLConnection) page.openConnection();
            conn.connect();
            InputStreamReader in = new InputStreamReader((InputStream) conn.getContent());
            BufferedReader buff = new BufferedReader(in);
            String line;
            while ((line = buff.readLine()) != null) {
                text.append(line + "\n");
            }
            Log.d("Runnable", "After IO call:"+ text.toString());
            Message msg = new Message();
            msg.obj = text.toString();
            responseHandler.sendMessage(msg);


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

Artigos úteis:

manipuladores-e-por-que-você-deveria-estar-usando-seus-aplicativos-android

android-looper-handler-handlerthread-i

Sei que essa é uma pergunta antiga, mas me deparei com uma linha principal de thread principal usada no Kotlin e no Java. Essa pode não ser a melhor solução para um serviço, mas chamar alguma coisa que altere a interface do usuário dentro de um fragmento é extremamente simples e óbvio.

Java (8):

 getActivity().runOnUiThread(()->{
      //your main thread code
 });

Kotlin:

this.runOnUiThread {
     //your main thread code
}

Siga este método. Usando essa maneira, você pode simplesmente atualizar a interface do usuário a partir de um thread em segundo plano. O runOnUiThread funciona no thread principal (UI). Eu acho que esse trecho de código é menos complexo e fácil, principalmente para iniciantes.

AsyncTask.execute(new Runnable() {
            @Override
            public void run() {

            //code you want to run on the background
            someCode();

           //the code you want to run on main thread
 MainActivity.this.runOnUiThread(new Runnable() {

                    public void run() {

/*the code you want to run after the background operation otherwise they will executed earlier and give you an error*/
                        executeAfterOperation();

                   }
                });
            }
        });

no caso de um serviço

crie um manipulador no oncreate

 handler = new Handler();

então use-o assim

 private void runOnUiThread(Runnable runnable) {
        handler.post(runnable);
    }

para Kotlin, você pode usar as corountines Anko :

atualizar

doAsync {
   ...
}

descontinuada

async(UI) {
    // Code run on UI thread
    // Use ref() instead of this@MyActivity
}

O mais útil é fazer o seguinte:

import android.os.AsyncTask
import android.os.Handler
import android.os.Looper

object Dispatch {
    fun asyncOnBackground(call: ()->Unit) {
        AsyncTask.execute {
            call()
        }
    }

    fun asyncOnMain(call: ()->Unit) {
        Handler(Looper.getMainLooper()).post {
            call()
        }
    }
}

E depois:

Dispatch.asyncOnBackground {
    val value = ...// super processing
    Dispatch.asyncOnMain { completion(value)}
}

public void mainWork() {
    new Handler(Looper.getMainLooper()).post(new Runnable() {
        @Override
        public void run() {
            //Add Your Code Here
        }
    });
}

Isso também pode funcionar em uma classe de serviço sem problemas.

Com o Kotlin, é assim dentro de qualquer função:

runOnUiThread {
   // Do work..
}