Android之进程通信机制（下）（AIDL,Messenger,Socket）

上篇博文，我们学习了IPC要用到的一些基本概念，接下来我们就要真刀真抢上战场啦。我们说过，Android的进程通信方法主要有Bundle，文件共享,Messenger，AIDL,ContentProvider，Socket.本篇博文，我们主要讲解Messenger(可翻译为信使),AIDL，Socket,因为Bundle,文件共享太简单了，而ContentProvider我们在Android的四大组件中已经学习过了。

一 Messenger

Messenger可翻译为信使，通过它可以在不同进程中传递Message对象,在Message中放入数据，就可以轻松实现数据的进程间传递了。Messenger 是一种轻量级的 IPC方案，它的底层实现是AIDL，它对AIDL进行了封装，使我们可以更简便的进行进程间通信。同时，由于它一次处理一个请求，因此在服务端我们不用考虑线程同步的问题，因为这时不存在并发处理执行的情形。实现一个Messenger有如下几个步骤，分为服务端和客户端.

(1).服务端进程

首先,我们需要在服务端创建一个Service来处理客户端请求，同时创建一个Handler并通过它来创建一个Messenger对象，然后再Service的onBind中返回这个Messenger对象底层的Binder即可。

 

(2).客户端进程

客户端进程中,首先要绑定服务端的Service，绑定成功后用服务端返回IBinder对象创建一个Messenger,通过这个Messenger就可以向服务端发送消息了，发消息类型为Message对象。如果需要服务端能够回应客户端，就和服务端一样，我们还需要创建一个Handler并创建一个新的Messenger，并把这个Messenger对象通过Message的replyTo参数传递给服务器，服务端通过这个replayTo参数就可以回应给客户端。

 

//MessengerActivity

package cn.tyssen.Messenger;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.*;
import android.util.Log;
import cn.tyssen.utils.MyConstants;

/**
 * Created by Tyssen on 2016/1/18.
 */
public class MessengerActivity extends Activity {

    private static final String TAG = "MessengerActivity";

    private Messenger mService;
    private Messenger mGetReplyMessenger = new Messenger(new MessengerHandler());

    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MyConstants.MSG_FROM_SERVICE:
                    Log.i(TAG, "receive msg from Service:" + msg.getData().getString("reply"));
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            mService = new Messenger(service);
            Log.d(TAG, "bind service");
            Message msg = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg", "hello, this is client.");
            msg.setData(data);
            msg.replyTo = mGetReplyMessenger;
            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        public void onServiceDisconnected(ComponentName className) {
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        Intent intent = new Intent("com.ryg.MessengerService.launch");
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onDestroy() {
        unbindService(mConnection);
        super.onDestroy();
    }
}

 

//MessengerService

package cn.tyssen.Messenger;

import android.app.Service;
import android.content.Intent;
import android.os.*;
import android.util.Log;
import cn.tyssen.utils.MyConstants;

/**
 * Created by Tyssen on 2016/1/18.
 */
public class MessengerService extends Service {

    private static final String TAG = "MessengerService";

    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MyConstants.MSG_FROM_CLIENT:
                    Log.i(TAG, "receive msg from Client:" + msg.getData().getString("msg"));
                    Messenger client = msg.replyTo;
                    Message relpyMessage = Message.obtain(null, MyConstants.MSG_FROM_SERVICE);
                    Bundle bundle = new Bundle();
                    bundle.putString("reply", "嗯，你的消息我已经收到，稍后会回复你。");
                    relpyMessage.setData(bundle);
                    try {
                        client.send(relpyMessage);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    private final Messenger mMessenger = new Messenger(new MessengerHandler());

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

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

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

}

 

 

 

 

二 AIDL

上面我们知道，Messenger是以串行的方式处理客户端发来的消息，如果大量的消息同时发送到服务端，服务端仍然只能一个处理，所以就不太合适用Messenger了。同时Messenger的作用主要为了传递消息，很多时候，我们可能需要跨进程调用服务端方法，这种情形，Messenger就无法做到了但我们可以使用AIDL.

使用AIDL分为服务端和客户端:

(1).服务端。

服务端首先要创建一个Service用来监听客户端的连接请求，然后创建一个AIDL文件，将暴露给客户端的接口在这个AIDL文件中声明,最后在Service中实现这个接口即可。

(2).客户端

客户端所要做的事情就稍微简单一些，首先需要绑定服务端的Service，绑定成功后，将服务端返回的Binder对象转成AIDL接口所属的类型，接着就可以调用AIDL中的方法了。

(3).AIDL接口的创建

 

在AIDL文件中，并不是所有的数据类型都可以使用的，那么到底AIDL文件支持哪些数据类型呢：

1.基本数据类型

2.String 和CharSequence

3.List 只支持ArrayList，里面每个元素都必须能够被AIDL支持。

4.Map 只支持HashMap，里面的每个元素都必须被AIDL支持，包括key和value.

5.Parcelabe 所有实现了Parcelable的接口对象

6.AIDL 所有的AIDL接口本身也可以在AIDL文件中使用。

 

如果自定义的Parceable对象和AIDL对象必须要显示import进来，不管他们是否和当前的AIDL文件位于同一个包内。另外，如果AIDL文件中用到了自定义的Parcelable对象，那么必须新建一个和它同名的AIDL文件，并在其中声明Parcelable类型

 

(4). 远程服务端Service的实现

(5). 客户端的实现

 

下面写一个AIDL的例子，实现了客户端调用服务端方法添加课本，删除课本，通知课本变化，以及权限验证。

//Book.java

 

package cn.tyssen.android.androidstudy;