Situación:

la actividad se enlaza al servicio de primer plano iniciado.El servicio reparte la carpeta local a la actividad.la actividad obtiene referencia al servicio a través de una llamada a getService ().la actividad quiere comunicarsedirectamente con un hilo que se ejecuta en el servicio mediante mensajes. Llama al método mService.getThreadHandler () desde la actividad.

Problema:

¿Cómo obtengo un Handler del hilo en ejecución actual en la actividad activa, de modo que pueda publicar mensajes directamente en la cola de mensajes de los hilos?

No sé qué utilizar un mensajero dentro del servicio, quiero comunicarme directamente con el hilo en el servicio desde el lado de la actividad.

Editar: la actividad obtiene el manejador del hilo en sí mismo en el servicio, llamando a algo como esto:

Código de actividad:

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 servicio:

private HandlerThread mServiceThread = new MyServiceThread();

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

Hace elnuevo controlador (mServiceThread.getLooper ()); devolver un nuevo controlador o el mismo controlador dentro del mServiceThread?

Edición 2: actualizando el código de servicio con el hilo de servicio que recibe los mensajes.

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

¿Correcto?