Situation:

Aktivität wird an den gestarteten Vordergrunddienst gebunden.Service übergibt lokales Bindemittel an Aktivität.Die Aktivität ruft durch einen Aufruf von getService () einen Verweis auf service ab.Aktivität will kommunizierendirekt mit einem Thread, der im Dienst mithilfe von Nachrichten ausgeführt wird. Es ruft die Methode mService.getThreadHandler () aus der Aktivität auf.

Problem:

Wie kann ich einen Handler aus dem aktuell ausgeführten Thread in die aktive Aktivität einbinden, damit ich Nachrichten direkt in die Nachrichtenwarteschlange des Threads stellen kann?

Ich kann keinen Messenger innerhalb des Dienstes verwenden, sondern möchte direkt mit dem Thread im Dienst von der Aktivitätsseite aus kommunizieren.

Bearbeiten: Die Aktivität ruft den Handler des Threads selbst im Service auf, indem sie etwa Folgendes aufruft:

Aktivitätscode:

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

Service code:

private HandlerThread mServiceThread = new MyServiceThread();

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

Tut dasneuer Handler (mServiceThread.getLooper ()); Einen neuen Handler oder denselben Handler in mServiceThread zurückgeben?

Bearbeiten 2: Aktualisieren des Dienstcodes mit dem Dienstthread, der die Nachrichten empfängt.

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

Richtig?