Android IPC进程间通信(从应用层源码分)《一》

在Android系统中，里面涉及到大量的进程间通信（IPC），现在我想自己写一篇关于我对IPC的理解，理解有不对的地方还希望大家给指点出来，IPC我打算分两篇来写，第一篇主要介绍怎么自己写一个进程间通信及AIDL，第二篇就从应用层源码分析，进程间是怎么绑定Binder进行进程间通信的。
首先我们要知道Binder这个概念，到底什么事Binder，其实说简单点，它就是进程与进程间进行通信的一个桥梁。
在通常的情况下，我们写一个AIDL，首先会定义一个AIDL接口，我们就叫他CalculateInterface.aidl类，里面定义了

package com.example.aidl.calculate;interface CalculateInterface {     double doCalculate(double a, double b); }

然后他就会在工程目录的gen下面产生一个同样类的名词.Java文件，点进去如下：

package com.example.aidl.calculate;public interface CalculateInterface extends android.os.IInterface {    /** Local-side IPC implementation stub class. */    public static abstract class Stub extends android.os.Binder implements            com.example.aidl.calculate.CalculateInterface {        private static final java.lang.String DESCRIPTOR = "com.example.aidl.calculate.CalculateInterface";        /** Construct the stub at attach it to the interface. */        public Stub() {            this.attachInterface(this, DESCRIPTOR);        }        /**         * Cast an IBinder object into an         * com.example.aidl.calculate.CalculateInterface interface, generating a         * proxy if needed.         */        public static com.example.aidl.calculate.CalculateInterface asInterface(                android.os.IBinder obj) {            if ((obj == null)) {                return null;            }            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);            if (((iin != null) && (iin instanceof com.example.aidl.calculate.CalculateInterface))) {                return ((com.example.aidl.calculate.CalculateInterface) iin);            }            return new com.example.aidl.calculate.CalculateInterface.Stub.Proxy(                    obj);        }        @Override        public android.os.IBinder asBinder() {            return this;        }        @Override        public boolean onTransact(int code, android.os.Parcel data,                android.os.Parcel reply, int flags)                throws android.os.RemoteException {            switch (code) {            case INTERFACE_TRANSACTION: {                reply.writeString(DESCRIPTOR);                return true;            }            case TRANSACTION_doCalculate: {                data.enforceInterface(DESCRIPTOR);                double _arg0;                _arg0 = data.readDouble();                double _arg1;                _arg1 = data.readDouble();                double _result = this.doCalculate(_arg0, _arg1);                reply.writeNoException();                reply.writeDouble(_result);                return true;            }            }            return super.onTransact(code, data, reply, flags);        }        private static class Proxy implements                com.example.aidl.calculate.CalculateInterface {            private android.os.IBinder mRemote;            Proxy(android.os.IBinder remote) {                mRemote = remote;            }            @Override            public android.os.IBinder asBinder() {                return mRemote;            }            public java.lang.String getInterfaceDescriptor() {                return DESCRIPTOR;            }            @Override            public double doCalculate(double a, double b)                    throws android.os.RemoteException {                android.os.Parcel _data = android.os.Parcel.obtain();                android.os.Parcel _reply = android.os.Parcel.obtain();                double _result;                try {                    _data.writeInterfaceToken(DESCRIPTOR);                    _data.writeDouble(a);                    _data.writeDouble(b);                    mRemote.transact(Stub.TRANSACTION_doCalculate, _data,                            _reply, 0);                    _reply.readException();                    _result = _reply.readDouble();                } finally {                    _reply.recycle();                    _data.recycle();                }                return _result;            }        }        static final int TRANSACTION_doCalculate = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);    }    public double doCalculate(double a, double b)            throws android.os.RemoteException;}

每一个AIDL生成的java文件，都必须有一个纯根（Stud）和一个代理类Proxy，在进程通讯中，Proxy主要负责发送数据，Stub主要负责接收数据，打一个比方，我们客户端发送数据的时候，是通过客户端的Proxy发送数据给服务端，然后服务端在Stub中就会回调onTransact方法，将数据读取出来，调用相应的方法，这样就完成了两个进程的通讯。
接下来我们自己写一个AIDL，不需要写AIDL文件和生成的代码，这样可以更好的看清楚两个进程是怎么发送数据和接受数据的。
我们首先新建一个接口，我取名叫IBookManager，继承IInterface这个接口，和写AIDL这个接口有点像，这里面也是写

public interface IBookManager extends IInterface{    //这是进程通讯的域名    static final String DESCRIPTOR = "com.example.aidl.calculate.IBookManager";    //给接口里面的方法定义一个ID，因为进程通讯里面，服务端是不认识我们所传的方法名，只认识ID，通过ID查找相应的方法。    static final int TRANSACTION_getBook = IBinder.FIRST_CALL_TRANSACTION+1;    //接口方法    public double getBook(double a1,double a2) throws RemoteException;    //BookManagerImpl相当于AIDL中的纯根(Stub)    public class BookManagerImplStub extends Binder implements IBookManager{        //初始化绑定信息        public BookManagerImplStub() {            this.attachInterface(this, DESCRIPTOR);        }        //这个相当于Stub中的代理类        //官方解释：一个内部对象到一个com.example.aidl.calculateIBookManager接口,生成一个        //如果需要代理。        public static IBookManager asInterface(IBinder iBinder){            if(iBinder == null){                return null;            }            //这里是判断是否在同一个进程，如果在就把自身给反回，如果不是就交给Prixy代理类            android.os.IInterface iin = iBinder.queryLocalInterface(DESCRIPTOR);            if((iin != null) && (iin instanceof IBookManager)){                return (IBookManager)iin;            }            return new Proxy(iBinder);        }        @Override        public IBinder asBinder() {            return this;        }        @Override        protected boolean onTransact(int code, Parcel data, Parcel reply,                int flags) throws RemoteException {            switch (code) {                case INTERFACE_TRANSACTION:{                    reply.writeString(DESCRIPTOR);                    return true;                }                //这个就是在服务端接受到的消息ID，通过消息ID查找相应的方法                case TRANSACTION_getBook:{                    data.enforceInterface(DESCRIPTOR);                    //这些取数据底层都是使用NDK，C/C++写的。                    double a1;                    a1 = data.readDouble();                    double a2;                    a2 = data.readDouble();                    //这里是得到值回调getBook方法                    double result = this.getBook(a1, a2);                    reply.writeNoException();                    reply.writeDouble(result);                    return true;                }            }            return super.onTransact(code, data, reply, flags);        }        @Override        public double getBook(double a1, double a2) throws RemoteException {            return a1 + a2;        }        //这个类部类中很重要的成员，负责发送数据        public static class Proxy implements IBookManager{            private IBinder iBinder;            public Proxy(IBinder iBinder){                this.iBinder = iBinder;            }            @Override            public IBinder asBinder() {                return iBinder;            }            @Override            public double getBook(double a1, double a2) throws RemoteException {                Parcel data = Parcel.obtain();                Parcel reply = Parcel.obtain();                double result = 0;                try {                    //验证通讯的Token，为了安全                    data.writeInterfaceToken(DESCRIPTOR);                    //写入数据                    data.writeDouble(a1);                    data.writeDouble(a2);                    iBinder.transact(TRANSACTION_getBook, data, reply, 0);                    reply.readException();                    result = reply.readDouble();                } catch (Exception e) {                    reply.recycle();                    data.recycle();                }                return result;            }        }    }}

这代码咋一看，怎么和自动生成的代码一摸一样，确实是一摸一样，这里只是为了让大家看得更清楚一点，代码里面的注释还是写的比较详细，相信大家也能看懂，现在我说下怎么使用吧，把IBookManager这个接口类在客户端和服务端要保证一摸一样。
客户端使用的方法。

public class MainActivity extends Activity {     private Button btnCalculate;     private EditText etNum1;     private EditText etNum2;     private TextView tvResult;     private IBookManager mService;     private ServiceConnection mServiceConnection = new ServiceConnection() {         @Override         public void onServiceDisconnected(ComponentName name) {             mService = null;         }         @Override         public void onServiceConnected(ComponentName name, IBinder service) {             mService = IBookManager.BookManagerImplStub.asInterface(service);             try {                 //在客户端链接服务端成功了，设置一个死亡代理，就是当服务端死亡之后会回调这么方法                service.linkToDeath(recipient, 0);            } catch (RemoteException e) {                e.printStackTrace();            }         }   };    @Override    protected void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.activity_main);        Intent intent = new Intent("com.example.aidldemoserver.BookService");        bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);         etNum1 = (EditText) findViewById(R.id.et_num_one);         etNum2 = (EditText) findViewById(R.id.et_num_two);         tvResult = (TextView) findViewById(R.id.tv_result);         btnCalculate = (Button) findViewById(R.id.btn_cal);         btnCalculate.setOnClickListener(new View.OnClickListener() {             @Override             public void onClick(View v) {                 logE("开始远程运算");                 try {                     double num1 = Double.parseDouble(etNum1.getText().toString());                     double num2 = Double.parseDouble(etNum2.getText().toString());                     String answer = "计算结果：" + mService.getBook(num1, num2);                     tvResult.setText(answer);                 } catch (RemoteException e) {                 }             }         });    }}

服务端的使用方法：

public class BookService extends Service {     private static final String TAG = "CalculateService";     @Override     public IBinder onBind(Intent arg0) {         return implStub;     }     @Override     public void onCreate() {         super.onCreate();     }     @Override     public boolean onUnbind(Intent intent) {         return super.onUnbind(intent);     }     @Override     public void onDestroy() {         super.onDestroy();     }     public IBookManager.BookManagerImplStub implStub = new IBookManager.BookManagerImplStub(); }

大致的流程就介绍到这里，有说得不对的地方还希望大家给指点出来，我会继续努力的，下篇我将从源码中介绍进程是怎么通信的。
Android IPC进程间通信(从应用层源码分)《二》