获得处理程序从服务到活动线程 [英] Getting a Handler from a Thread from Service to Activity

问题描述

情况：

1. 活动结合启动前台服务。
2. 在服务递给了当地的粘合剂的活动。
3. 活动获得基准通过的getService（）调用的服务。
4. 活动想要传达的直接在使用邮件服务中的线程中运行。它要求从活动mService.getThreadHandler（）方法。

1. activity binds to started foreground service.
2. service hands out local binder to activity.
3. activity gets reference to service through a getService() call.
4. activity wants to communicate directly with a thread running in the service using messages. It calls the mService.getThreadHandler() method from the activity.

问题：

• 我如何才能从当前运行线程处理程序到活动活动，这样我就可以直接发帖到线程messagequeue？

我不给服务中使用的使者，我想直接从活动方的服务线程通信。

I don't what to use a messenger within the service, I want to directly communicate with the thread in the service from the activity side.

编辑：活动得到线程自身在服务，的处理程序通过调用是这样的：

the activity gets the handler of the thread itself in the service, by calling something like this:

活动code：

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

服务code：

Service code:

private HandlerThread mServiceThread = new MyServiceThread();

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

请问在新的处理程序（mServiceThread.getLooper（））;？返回一个新的处理程序或mServiceThread在相同的处理器

Does the new Handler(mServiceThread.getLooper()); return a new Handler or the same Handler within the mServiceThread?

编辑2：与接收邮件的serviceThread更新服务code

Edit 2: updating the Service code with the serviceThread which receives the messages.

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

正确的？

推荐答案

试试这个（我用的活动来测试它，你将使用服务）：

try this (i used Activity to test it you will use Service):

protected void onCreate(Bundle savedInstanceState) {
    ht = new HandlerThread("HT");
    ht.start();
    htHandler = new Handler(ht.getLooper(), htCallback);
    mainHandler = new Handler(mainCallback);
    for (int i = 0; i < 10; i++) {
        htHandler.sendMessageDelayed(htHandler.obtainMessage(99, i, 0), i * 3000);
    }
}

private HandlerThread ht;
private Handler htHandler;
private Handler mainHandler;

private Callback htCallback = new Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        Log.d(TAG, "handleMessage **********************");
        Log.d(TAG, "handleMessage " + msg);
        Log.d(TAG, "handleMessage Thread: " + Thread.currentThread());
        if (msg.arg1 == 4) {
            Log.d(TAG, "handleMessage sending back to Main thread");
            mainHandler.sendEmptyMessage(101);
        }
        return false;
    }
}; 

private Callback mainCallback = new Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        Log.d(TAG, "handleMessage ########################");
        Log.d(TAG, "handleMessage " + msg);
        Log.d(TAG, "handleMessage Thread: " + Thread.currentThread());
        Log.d(TAG, "handleMessage i'm quitting");
        ht.quit();
        return false;
    }
}; 

这篇关于获得处理程序从服务到活动线程的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！