Android使用Messenger实现进程间双向通信

在了解本文即将学到的技能外，有些知识还是有必要提前知道的，这样才会更容易理解本文即将讲到的知识点。需要提前预热的知识点：

1、Android四大组件之一Service，要知道怎样去写一个Service，Service有哪两种启动方式；

2、Android Service启动方式之Bound Service；

3、Android基础知识之Messenger；

掌握了这三个知识点，就可以快速入手使用Messenger进行进程间通信了。

一、知识点回顾之Service

我们来看看官方文档关于对Service最权威的解释：

Service是一个应用程序组件，它能够在后台执行一些耗时较长的操作，并且不提供用户界面。服务能被其它应用程序的组件启动，即使用户切换到另外的应用时还能保持后台运行。此外，应用程序组件还能与服务绑定，并与服务进行交互，甚至能进行进程间通信（IPC）。 比如，服务可以处理网络传输、音乐播放、执行文件I/O、或者与content provider进行交互，所有这些都是后台进行的。

服务有以下两种基本类型：

Started 

如果一个应用程序组件（比如一个activity）通过调用startService()来启动服务，则该服务就是被“started”了。一旦被启动，服务就能在后台一直运行下去，即使启动它的组件已经被销毁了。 通常，started的服务执行单一的操作并且不会向调用者返回结果。比如，它可以通过网络下载或上传文件。当操作完成后，服务应该自行终止。

Bound 

如果一个应用程序组件通过调用bindService()绑定到服务上，则该服务就是被“bound”了。bound服务提供了一个客户端/服务器接口，允许组件与服务进行交互、发送请求、获取结果，甚至可以利用进程间通信（IPC）跨进程执行这些操作。绑定服务的生存期和被绑定的应用程序组件一致。 多个组件可以同时与一个服务绑定，不过所有的组件解除绑定后，服务也就会被销毁。

虽然本文对这两种类型的服务是分别进行简要描述的，但是你的服务仍可以同时用两种方式工作——可以是started（一直运行下去），同时也能被绑定。 只会存在一点麻烦，是否两个回调方法都要实现：实现onStartCommand()以允许组件启动服务、实现onBind()以允许绑定。

无论你的应用程序是started、bound、还是两者都支持，任何应用程序组件都可以使用此服务（即使是从另一个独立的应用程序中）， 同样，任何组件都可以用这种方式使用一个activity——通过一个Intent启动。不过，也可以在manifest文件中把服务声明为私有private的，以便阻止其它应用程序的访问。 

Service的两种启动模式

在创建一个Service之前，需要继承Service类，重写一些回调方法。Service最重要的两个回调方法就是onStartCommand()和onBind()，基于这两个方法的重写也就决定了Service的启动模式。如果onBind()方法中返回null，说明Service需要通过startService()启动，如果onBind()返回一个IBinder，说明Service可以通过bindService()进行服务绑定，从而启用Service；

onStartCommand()

当其它组件，比如一个activity，通过调用startService()请求started方式的服务时，系统将会调用本方法。 一旦本方法执行，服务就被启动，并在后台一直运行下去。 如果你的代码实现了本方法，你就有责任在完成工作后通过调用stopSelf()或stopService()终止服务。 （如果你只想提供bind方式，那就不需要实现本方法。）

onBind()

当其它组件需要通过bindService()绑定服务时（比如执行RPC），系统会调用本方法。 在本方法的实现代码中，你必须返回IBinder来提供一个接口，客户端用它来和服务进行通信。 你必须确保实现本方法，不过假如你不需要提供绑定，那就返回null即可。

onCreate()

当服务第一次被创建时，系统会调用本方法，用于执行一次性的配置工作（之前已调用过onStartCommand()或onBind()) 了。如果服务已经运行，则本方法就不会被调用。

onDestroy()

当服务用不上了并要被销毁时，系统会调用本方法。 你的服务应该实现本方法来进行资源的清理工作，诸如线程、已注册的侦听器listener和接收器receiver等等。 这将是服务收到的最后一个调用。

如果组件通过调用startService()（这会导致onStartCommand()的调用）启动了服务，那么服务将一直保持运行，直至自行用stopSelf()终止或由其它组件调用stopService()来终止它。

如果组件调用bindService()来创建服务（那onStartCommand()就不会被调用），则服务的生存期就与被绑定的组件一致。一旦所有客户端都对服务解除了绑定，系统就会销毁该服务。

started服务是指其它组件通过调用startService()来启动的服务，这会引发对该服务onStartCommand()方法的调用。

一旦服务被启动started，它就拥有了自己的生命周期，这是独立于启动它的组件的。并且它能够在后台一直运行下去，即使启动它的组件已被销毁 也是如此。 因此，服务应该能够在完成工作后自行终止，通过调用stopSelf()即可，或者由其它组件通过调用stopService()也可以。

诸如activity之类的应用程序组件，可以通过调用startService()启动服务,并传入一个给出了服务和服务所需数据的Intent对象。服务将在onStartCommand()方法中接收到该Intent对象。

Service

这是所有服务的基类。如果你要扩展该类，则很重要的一点是：请在其中创建一个新的线程来完成所有的服务工作。 因为服务默认是使用应用程序的主线程的，这会降低应用程序中activity的运行性能。

package com.lc.proctice.androidstudioproctice.myservice;

import android.app.Service;
import android.content.Intent;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.IBinder;
import android.os.Looper;
import android.os.Message;
import android.os.Process;
import android.support.annotation.Nullable;

/**
 * Created by licheng on 24/7/16.
 */
public class HelloService extends Service {

    private ServiceHandler serviceHandler;
    private Looper looper;



    /** 处理从线程获取到的消息 **/
    private final class ServiceHandler extends Handler{

        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            /** 线程等待5秒 **/
            long endTime = System.currentTimeMillis() + 5*1000;
            while (System.currentTimeMillis() < endTime) {
                synchronized (this) {
                    try {
                        wait(endTime - System.currentTimeMillis());
                    } catch (Exception e) {
                    }
                }
            }
            /** 根据startId停止当前服务,这样我们就不必要在处理其他工作的过程中来终止这个服务 **/
            stopSelf(msg.arg1);
        }
    }

    @Override
    public void onCreate() {
        super.onCreate();
        /** Service运行在主线程,为了不阻塞线程,我们需要另起线程,还可以赋予线程优先级 **/
        HandlerThread handlerThread = new HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND);
        handlerThread.start();

        /** 获取线程的Looper队列用于Handler **/
        looper = handlerThread.getLooper();
        serviceHandler = new ServiceHandler(looper);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        /** 发送消息,传入当前服务startId **/
        Message msg = serviceHandler.obtainMessage();
        msg.arg1 = startId;
        serviceHandler.sendMessage(msg);
        /** 如果服务被杀死,从这里返回后服务将被重启 **/
        return START_STICKY;
    }

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        /** 如果不支持绑定,就返回Null **/
        return null;
    }
}

关于HandlerThread，可以参考这篇博文Android HandlerThread完全解析

启动服务

从activity或其它应用程序组件中可以启动一个服务，调用startService()并传入一个Intent（指定所需启动的服务）即可。Android系统将调用服务的onStartCommand()方法，并传入该Intent（你永远都不应该直接去调用onStartCommand()。）

例如，一个activity可以用一个显式的intent通过startService()启动上一节的示例服务（HelloSevice）：

Intent intent = new Intent(this, HelloService.class);
startService(intent);

startService()方法会立即返回，Android系统会去调用服务的onStartCommand() 方法。如果服务还未运行，系统会首先调用onCreate()，然后再去调用onStartCommand() 。

如果服务不同时支持绑定，那么通过startService()传入的intent将是应用程序组件与服务进行交互的唯一途径。 当然，如果你期望服务能返回结果，那启动服务的客户端可以创建一个PendingIntent来获得一个广播broadcast（利用getBroadcast()），并把它放入启动服务的Intent并传到服务中去。然后服务就会用这个broadcast来传递结果。

多个启动服务的请求将会引发服务onStartCommand()方法的多次调用。不过，只有一个终止服务的请求（用stopSelf()或stopService()）会被接受并执行。

一个started服务必须自行管理生命周期。也就是说，系统不会终止或销毁这类服务，除非必须恢复系统内存并且服务返回后一直维持运行。 因此，服务必须通过调用stopSelf()自行终止，或者其它组件可通过调用stopService()来终止它。

用stopSelf()或stopService()的终止请求一旦发出，系统就会尽快销毁服务。

不过，如果你的服务要同时处理多个onStartCommand()请求，那在处理启动请求的过程中，你就不应该去终止服务，因为你可能接收到了一个新的启动请求（在第一个请求处理完毕后终止服务将停止第二个请求的处理。 为了避免这个问题，你可以用stopSelf(int)来确保终止服务的请求总是根据最近一次的启动请求来完成。 也就是说，当你调用stopSelf(int) 时，你把启动请求ID（发送给onStartCommand()的startId）传给了对应的终止请求。这样，如果服务在你可以调用stopSelf(int)时接收到了新的启动请求，则ID将会不一样，服务将不会被终止。

启动服务前还需要在manifest.xml文件声明Service，这样才能保证服务正常工作。

要声明你的服务，把<service>元素作为子元素加入到<application>元素中去即可。例如：

<manifest ... >
  ...
  <application ... >
      <service android:name=".ExampleService" />
      ...
  </application>
</manifest>

在<service>元素中可以包含很多其它属性，比如定义启动服务所需权限、服务运行的进程之类的属性。

bound服务是指允许被应用程序组件绑定的服务，通过调用bindService()可以完成绑定，用于创建一个长期存在的连接（并且一般不再允许组件通过调用startService()来start服务。

当应用程序中的activity或其它组件需要与服务进行交互，或者应用程序的某些功能需要暴露给其它应用程序时，你应该创建一个bound服务，并通过进程间通信（IPC）来完成。

要创建一个bound服务，你必须实现onBind()回调方法，并返回一个IBinder对象，此对象定义了与服务进行通信的接口。 然后，其它应用程序组件可以调用bindService()来获得接口并调用服务中的方法。 服务只在为绑定的应用程序组件工作时才会存活，因此，只要没有组件绑定到服务，系统就会自动销毁服务（你不需要像started服务中那样通过onStartCommand()来终止一个bound服务）。

要创建一个bound服务，首先必须定义好接口，用于指明客户端如何与服务进行通信。 这个客户端与服务之间的接口必须是一个IBinder对象的实现，并且你的服务必须在onBind()回调方法中返回这个对象。一旦客户端接收到这个IBinder，它就可以通过这个接口来与服务进行交互。

同一个服务可以被多个客户端绑定。当客户端完成交互时，会调用unbindService()来解除绑定。一旦不存在客户端与服务绑定时，系统就会销毁该服务。

package com.lc.proctice.androidstudioproctice.myservice;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

/**
 * Created by licheng on 18/8/15.
 */
public class BindService extends Service {
    private static final String TAG = "BindService";
    private int count=0;
    private boolean quit=false;
    private Thread thread;
    private MyBinder binder=new MyBinder();

    /** 创建和和客户端通信的Binder,公开它的方法,便于客户端调用 **/
    public class MyBinder extends Binder{
        public int getCount(){
            return count;
        }
    }

    @Override
    public void onCreate() {
        super.onCreate();
        Log.v(TAG, "service is onCreate");
        /** 另起线程 **/
        thread = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!quit) {
                    try {
                        thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count++;
                }
            }
        });
        thread.start();
    }

    @Override
    public IBinder onBind(Intent intent) {
        Log.v(TAG, "Service is Binded");
        return binder;
    }

    @Override
    public void onStart(Intent intent, int startId) {
        super.onStart(intent, startId);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.v(TAG, "Service is started");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.v(TAG, "Service is Unbinded");
        return true;
    }

    @Override
    public void onDestroy() {
        Log.v(TAG,"service is destroyed");
        this.quit = true;
    }
}

应用程序组件（客户端）可以通过调用 bindService() 来绑定服务。然后Android系统会调用服务的 onBind() 方法，返回一个用于和服务进行交互的 IBinder。

绑定是异步进行的。 bindService() 将立即返回，并不会向客户端返回 IBinder 。为了接收 IBinder ，客户端必须创建一个 ServiceConnection 的实例，并把它传给 bindService()。 ServiceConnection 包含了一个回调方法，系统将会调用该方法来传递客户端所需的那个 IBinder。

因此，要把客户端绑定到服务上，你必须：

1. 实现ServiceConnection。

   你的实现代码必须重写两个回调方法：

   onServiceConnected()

   系统调用该方法来传递服务的onBind()方法所返回的IBinder。

   onServiceDisconnected()

   当与服务的联接发生意外中断时，比如服务崩溃或者被杀死时，Android系统将会调用该方法。客户端解除绑定时，不会调用该方法。

2. 调用bindService()，传入已实现的ServiceConnection。
3. 当系统调用你的onServiceConnected()回调方法时，你可以利用接口中定义的方法开始对服务的调用。
4. 要断开与服务的联接，请调用unbindService()。

当客户端被销毁时，与服务的绑定也将解除。但与服务交互完毕后，或者你的activity进入pause状态时，你都应该确保解除绑定，以便服务能够在用完后及时关闭。（绑定和解除绑定的合适时机将在后续章节中继续讨论。）

private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            Log.i(TAG, "--Service Connected--");
            // 取得Service对象中的Binder对象
            binder = (BindService.MyBinder) service;
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.i(TAG, "--Service Disconnected--");
        }
    };

 Intent intent = new Intent(ServiceActivity.this, BindService.class);
 bindService(intent, connection, Service.BIND_AUTO_CREATE);

注意：BindService需要在manifest.xml文件中声明。

以上关于Service的两种启动模式就讲到这里啦，关于Android Service 的Bound服务，这里也很有必要将清楚，因为在介绍了这么多准备知识后，我们还没有进入到这篇文章的主题，使用Messenger进行进程间通信。

Android Bound服务

bound服务是客户端-服务器模式的服务。bound服务允许组件（比如activity）对其进行绑定、发送请求、接收响应、甚至进行进程间通信（IPC）。 bound服务一般只在为其它应用程序组件服务期间才是存活的，而不会一直在后台保持运行。

bound服务是 Service 类的一种实现，它允许其它应用程序与其绑定并交互。为了让服务支持绑定，你必须实现onBind() 回调方法。这个方法返回一个 IBinder 对象，此对象定义了客户端与服务进行交互时所需的编程接口。

客户端可以通过调用 bindService() 方法来绑定服务。在调用时，必须提供一个 ServiceConnection 的实现代码，用于监控与服务的联接。 bindService() 将会立即返回，没有返回值。但是Android系统在创建客户端与服务之间的联接时，会调用 ServiceConnection 中的onServiceConnected() 方法，传递一个 IBinder ，客户端将用它与服务进行通信。

多个客户端可以同时联接到一个服务上。不过，只有在第一个客户端绑定时，系统才会调用服务的 onBind()方法来获取 IBinder 。然后，系统会向后续请求绑定的客户端传送这同一个 IBinder ，而不再调用 onBind() 。

当最后一个客户端解除绑定后，系统会销毁服务（除非服务同时是通过 startService() 启动的）。

当你实现自己的bound服务时，最重要的工作就是定义onBind() 回调方法所返回的接口。定义服务 IBinder 接口的方式有好几种，后续章节将会对每种技术进行论述。

定义IBinder的三种方式

创建一个支持绑定的服务时，你必须提供一个 IBinder，用作客户端和服务间进行通信的编程接口。定义这类接口的方式有三种：

扩展Binder类

如果服务是你的应用程序所私有的，并且与客户端运行于同一个进程中（通常都是如此），你应该通过扩展Binder类来创建你的接口,并从onBind()返回一个它的实例。客户端接收该Binder对象并用它来直接访问Binder甚至Service中可用的公共（public）方法。

如果你的服务只是为你自己的应用程序执行一些后台工作，那这就是首选的技术方案。不用这种方式来创建接口的理由只有一个，就是服务要被其它应用程序使用或者要跨多个进程使用。

使用Messenger

如果你需要接口跨越多个进程进行工作，可以通过Messenger来为服务创建接口。在这种方式下，服务定义一个响应各类消息对象Message的Handler。此Handler是Messenger与客户端共享同一个IBinder的基础，它使得客户端可以用消息对象Message向服务发送指令。此外，客户端还可以定义自己的Message，以便服务能够往回发送消息。

这是执行进程间通信（IPC）最为简便的方式，因为Messenger会把所有的请求放入一个独立进程中的队列，这样你就不一定非要把服务设计为线程安全的模式了。

使用AIDL

Android接口定义语言AIDL（Android Interface Definition Language）完成以下的所有工作：将对象解析为操作系统可识别的原始形态，并将它们跨进程序列化（marshal）以完成IPC。前一个使用Messenger的方式，实际上也是基于AIDL的，它用AIDL作为底层结构。如上所述，Messenger将在一个单独的进程中创建一个包含了所有客户端请求的队列，这样服务每次就只会收到一个请求。可是，如果想让你的服务能同时处理多个请求，那你就可以直接使用AIDL。这种情况下，你的服务必须拥有多线程处理能力，并且是以线程安全的方式编写的。

要直接使用AIDL，你必须创建一个.aidl文件，其中定义了编程的接口。Android SDK 工具使用此文件来生成一个抽象类（abstract class），其中实现了接口及对IPC的处理，然后你就可以在自己的服务中扩展该类。

上文BindService中的Ibinder实现方式就采用了方式一，扩展Binder类，实现了客户端和服务端的数据交互。

接下来进入本文的正题了，用方式二实现IBinder，即通过Messenger实现IBinder，进一步实现客户端和服务端的数据双向交互。

使用Messenger

如果你的服务需要与远程进程进行通信，那你可以使用一个 Messenger 来提供服务的接口。这种技术能让你无需使用AIDL就能进行进程间通信（IPC）。

以下概括了Messenger的使用方法:

• 服务实现一个Handler ，用于客户端每次调用时接收回调。
• 此Handler用于创建一个Messenger对象（它是一个对Handler的引用)。
• 此Messenger对象创建一个IBinder，服务在onBind()中把它返回给客户端。
• 客户端用IBinder将Messenger（引用服务的Handler）实例化，客户端用它向服务发送消息对象Message。
• 服务接收Handler中的每个消息Message——确切的说，是在handleMessage()方法中接收。

通过这种方式，客户端不需要调用服务中的“方法”。取而代之的是，客户端发送“消息”（ Message对象），服务则接收位于 Handler中的这个消息。

package com.lc.proctice.androidstudioproctice.myservice;

import android.app.Service;
import android.content.Intent;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.support.annotation.Nullable;
import android.widget.Toast;

/**
 * Created by licheng on 23/7/16.
 */
public class MessengerService extends Service {

    public static final int MSG_SAY_HELLOW = 1;
    /**
     * 从客户端接收消息的Handler
     */
    class IncomingHandler extends Handler{
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case MSG_SAY_HELLOW:
                    Toast.makeText(getApplicationContext(),"hellow",Toast.LENGTH_SHORT).show();
                    repalyMessenger = msg.replyTo;
                    /** 开启一个线程模拟,三秒后回传服务器数据给客户端 **/
                    new ReplayThread().start();
                    break;
                default:
                    super.handleMessage(msg);
            }

        }
    }

    /**
     * 向客户端公布的用于向IncomingHandler发送信息的Messager
     */
    final Messenger messenger = new Messenger(new IncomingHandler());

    /** 用于接收客户端回传来的messenger **/
    private Messenger repalyMessenger = null;


    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        return super.onStartCommand(intent, flags, startId);
    }

    /**
     * 当绑定到服务时，我们向Messager返回接口，
     * 用于向服务发送消息
     */
    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return messenger.getBinder();
    }

    private class ReplayThread extends Thread{

        @Override
        public void run() {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            /** 服务端向客户端发送消息 **/
            Message msg = new Message();
            msg.what = 111;
            try {
                if(null != repalyMessenger)
                repalyMessenger.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

    }
}

package com.lc.proctice.androidstudioproctice.myservice;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.view.View;
import android.widget.Button;
import android.widget.Toast;

import com.lc.proctice.androidstudioproctice.R;

/**
 * Created by licheng on 23/7/16.
 */
public class MessengerActivity extends Activity {

    private Button btnGetMessage;

    private boolean mBound;

    /** 用于和服务通信的messager **/
    private Messenger mService = null;

    /** 用于回传的messenger **/
    private Messenger sendMessenger = null;

    /** 用于处理服务端向客户端发送的消息 **/
    private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            if(msg.what == 111){
                Toast.makeText(MessengerActivity.this, "服务器给客户端回传的消息", Toast.LENGTH_SHORT).show();
            }
        }
    };


    private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // 与服务建立联接后将会调用本方法，
            // 给出用于和服务交互的对象。
            // 我们将用一个Messenger来与服务进行通信，
            // 因此这里我们获取到一个原始IBinder对象的客户端实例。
            mBound = true;
            mService = new Messenger(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            mService = null;
            mBound = false;
        }
    };

    /** 客户端向服务端发送消息 **/
    public void sayHello(){
        if(!mBound) return;

        sendMessenger = new Messenger(handler);
        // 创建并向服务发送一个消息，用到了已约定的'what'值
        Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLOW, 0, 0);
        try {
            msg.replyTo = sendMessenger;
            mService.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }


    @Override
    protected void onStart() {
        super.onStart();
        /** 绑定服务 **/
        bindService(new Intent(this, MessengerService.class), connection, BIND_AUTO_CREATE);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        btnGetMessage = (Button) findViewById(R.id.btnGetMessage);
        btnGetMessage.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                sayHello();
            }
        });
    }

    @Override
    protected void onStop() {
        super.onStop();
        if(mBound){
            unbindService(connection);
            mBound = false;
        }
    }



}

注意：如果你需要服务进行响应，那你还需要在客户端创建一个Messenger。然后，当客户端接收到 onServiceConnected() 回调后，它再发送一个消息Message 给服务，消息的send() 方法中的replyTo 参数里包含了客户端的Messenger。

运行MessengerActivity，点击进程通信按钮，就可以首先看到客户端发送到服务端的“hellow”消息，3秒后，就可以看到服务端发送给客户端的“服务端给客户端回传的消息”消息，大公告成，使用Messenger实现了Activity和Service的数据双向互通。

与AIDL相比，当你需要进行IPC时，使用 Messenger 要比用AIDL实现接口要容易些，因为 Messenger 会把所有调用服务的请求放入一个队列。而纯粹的AIDL接口会把这些请求同时发送给服务，这样服务就必须要能够多线程运行。

对于绝大多数应用程序而言，服务没有必要多线程运行，因此利用 Messenger 可以让服务一次只处理一个调用。如果 你的服务非要多线程运行，那你就应该用 AIDL 来定义接口。

关于使用AIDL实现进程间的通信教程后面会贴出来，敬请期待。

本文参考资料：Google官方文档 http://www.android-doc.com/guide/components/bound-services.html

Android使用Messenger实现进程间双向通信

原文：http://blog.csdn.net/u011459799/article/details/52012606