Android进程间通信之Messenger

在安卓中进程间通信的方式有多种，其中我感觉最简单的应该是Messenger。messenger直接翻译过来意味“信使“，我们可以将Message对象通过Messenger发送给其它进程，从而实现进程间的通信。Messenger的底层是通过AIDL来实现的，所以它的使用会比AIDL来的更简单。下面给出两个Messenger的构造函数，之后我们会用到的：

public Messenger(Handler handler){
    mTarget=handler.getIMessenger();
}
public Messenger(IBinder target){
    mTarget=IMessenger.Stub.asInterface(target);
}

首先建立服务端代码

服务端使用Service实现，需要在manifests中注册并声明android:process=":test",让该Service运行在test进程中。贴代码时间到：

public class MyService extends Service {


    private static final String TAG=MyService.class.getSimpleName();

    Messenger mClientMessenger;

    Messenger mServiceMessenger;

    Handler mHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            if (msg.what == 0x001) {
                //取出数据  并打印
                Bundle bundle=msg.getData();
                Log.d(TAG,bundle.getString("data"));

                //获取客户端的Messenger
                mClientMessenger = msg.replyTo;

                //构造发送给客户端数据 并发送
                Message msg1 = new Message();
                msg1.what = 0x001;
                Bundle data=new Bundle();
                data.putString("data","hello i am server");
                msg1.setData(data);
                try {
                    mClientMessenger.send(msg1);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
    };

    public MyService() {
        //当service 创建的时候 使用Handler生成服务端Messenger
        mServiceMessenger = new Messenger(mHandler);
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mServiceMessenger.getBinder();
    }
}

当Service在被创建的时候我们生成一个Messenger，在onBind方法中返回Messenger的底层Binder给客户端，客户端拿到这个Binder然后利用开头说的构造方法即可构造出Messenger对象。通过这个机制客户端就顺利的拿到了发送消息给服务端的Messenger的对象了。

建立客户端代码

客户端的话我们在一个Activity中绑定这个Service。

public class MainActivity extends AppCompatActivity {

    private static final String TAG=MainActivity.class.getSimpleName();

    private Handler mHandler = new Handler() {
        public void handleMessage(android.os.Message msg) {
            if (msg.what == 0x001) {
                Bundle data=msg.getData();
                Log.d(TAG,data.getString("data"));
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Intent intent = new Intent(this, MyService.class);
        bindService(intent, mConnection, BIND_AUTO_CREATE);
    }

    ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            Messenger messenger = new Messenger(iBinder);
            Message msg = new Message();
            Bundle data=new Bundle();
            data.putString("data","hello i am client");
            msg.setData(data);
            msg.what = 0x001;
            msg.replyTo = new Messenger(mHandler);
            try {
                messenger.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            System.out.println("onServiceDisconnected = [" + componentName + "]");
        }
    };
}

在这里，我们通过bindService方法绑定后台进程服务，在绑定成功的时候会回调ServiceConnection中onServiceConnected方法，我们在这里获取到后台进程返回的IBinder,然后构造出后台进程的Messenger对象，当我们想要后台进程收到消息给前台进程一个反馈，我们需要将前台进程的Messenger返回给后台进程。在这里，我们将前台进程的Messenger对象直接赋值给Message的replyTo属性，然后发送给后台进程，后台进程拿到前台进程的Messenger即可进行通信了。