Situação:

atividade liga-se ao serviço de primeiro plano iniciado.serviço distribui fichário local para atividade.atividade obtém referência ao serviço por meio de uma chamada getService ().atividade quer se comunicardiretamente com um encadeamento em execução no serviço usando mensagens. Ele chama o método mService.getThreadHandler () da atividade.

Problema:

Como faço para obter um manipulador do thread em execução atual para a atividade ativa, para que eu possa enviar mensagens diretamente para o messagequeue threads?

Eu não sei o que usar um mensageiro dentro do serviço, eu quero me comunicar diretamente com o segmento no serviço do lado da atividade.

Editar: a atividade obtém o manipulador do próprio encadeamento no serviço, chamando algo assim:

Código de atividade:

Handler mServiceThreadHandler;
ServiceConnection mServiceConnection;

public void onStart() {
  if (!bindService(new Intent(this, MainService.class), mServiceConnection,    Context.BIND_AUTO_CREATE)) 
  {
    Log.e(TAG, "Client did not bind to Service!");
  } 
  super.onStart();
}

public class MyLocalServiceConnection implements ServiceConnection {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        LocalBinder binder = (LocalBinder) service;
        mService = (MainService) binder.getService();
                    // the handler of the service is actually a handler of a thread
                    // within the service, and is set automatically within the binding
                    // activity when binding to the service. That way you have a direct
                    // "connection" with the message queue of the thread instead of
                    // a message queue in the service itself (main thread of service)
        mServiceThreadHandler = mService.getServiceHandler();

        if (mServiceThreadHandler == null) {
            Log.e(TAG, "Service handler is NULL");
        }
        mBoundedToService = true;
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
        mServiceThreadHandler = null;
        mBoundedToService = false;
    }
}

Código de serviço:

private HandlerThread mServiceThread = new MyServiceThread();

public Handler getServiceHandler() {
    return new Handler(mServiceThread.getLooper());
}

Onovo manipulador (mServiceThread.getLooper ()); retornar um novo manipulador ou o mesmo manipulador dentro do mServiceThread?

Editar 2: atualizando o código de serviço com o serviceThread que recebe as mensagens.

public class MyService extends Service {
  private MyHandlerThread serviceThread = new MyHandlerThread("serviceThread");

  serviceThread.start();

public Handler getServiceHandler() {
  // hand out the same handler of the service thread for using it in an activity!
  // serviceThread.getLooper() is the current looper of the thread
  // serviceThread is the 'this' which handles the messages (see MyHandlerThread)
  return new Handler(serviceThread.getLooper(), serviceThread); 
}

  // do stuff in Service
}

public class MyHandlerThread extends HandlerThread implements android.os.Handler.Callback {
public MyHandlerThread(String name) {
    super(name);
}
public MyHandlerThread(String name, int priority) {
    super(name, priority);
}
@Override
public boolean handleMessage(Message msg) {
    // TODO define your own message handling here.
    return false;
}
}

Corrigir?