神刀安全网

Android进程间通信机制Binder应用层分析

1. 概述

学姐今天复习了下Android进程间通信方式,打算从 基本概念使用原因基本使用原理分析 几个方面来讲讲。

想要对进程间通信方式有个相对全面的了解,就先从几个比较重要的概念 IPCAIDLBinder 说起吧。

(1) IPC :Inter-Process Communication,即进程间通信

(2) AIDL :Android Interface Definition Language,即Android接口定义语言。Client和Service要实现

跨进程通信,必须遵循的接口规范。需要创建.aidl文件,外在表现上和Java中的interface有点类似。

(3) Binder :Android进程间通信是通过 Binder 来实现的。远程Service在Client绑定服务时,会在onBind()的回调中返回一个Binder,当Client调用bindService()与远程Service建立连接成功时,会拿到远程Binder实例,从而使用远程Service提供的服务。

2. 为什么使用Binder?

下面内容学姐参考别人的博文,进行了总结。

Linux系统进程间通信方式:

(1)传统机制。如管道(Pipe)、信号(Signal)和跟踪(Trace),适用于父子进程或兄弟进程,其中命名管道(Named Pipe),支持多种类型进程

(2)System V IPC机制。如报文队列(Message)、共享内存(Share Memory)和信号量(Semaphore)

(3)Socket通信

然而,以上方式在性能和安全性方面存在不足:

(1)性能方面。管道和队列采用存储转发方式,数据从发送方缓存区->内核缓存区->接收方缓存区,会经历两次拷贝过程;共享内存无拷贝但控制复杂;Socket传输效率低下,且连接的建立与中断有一定开销。

(2)安全性方面。传统IPC方式无法获得对方进程可靠的UID和PID,无法鉴别对方身份,若采用在数据包里填入UID/PID的方式,容易被恶意程序利用;传统IPC方式的接入点是开放性的,无法建立私有通道,容易被恶意程序猜测出接收方地址,获得连接。

Binder 是基于C/S通信模式,传输过程只需要一次拷贝,且为Client添加UID/PID身份,性能和安全性更好,因此Android进程间通信使用了 Binder

3. 基本使用

假设本地Client需要使用远程Service的计算器功能。示例Demo: binderDemo

(1)新建Client和远程Service两个Android工程。

(2)在远程Service工程中,创建ICalculator.aidl文件,并创建CalculatorService类。

// ICalculator.aidl package me.wangxinghe.ipc;  // Declare any non-default types here with import statements  interface ICalculator {     /**      * Demonstrates some basic types that you can use as parameters      * and return values in AIDL.      */     void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,             double aDouble, String aString);      int add(int a, int b);     int minus(int a, int b); }  //给Client提供服务的Service文件 public class CalculatorService extends Service {     public CalculatorService() {     }      @Override     public void onCreate() {         super.onCreate();     }      @Override     public IBinder onBind(Intent intent) {         //当Client调用bindService()时,远程Service通过onBind()回调返给Client         return mBinder;     }      @Override     public int onStartCommand(Intent intent, int flags, int startId) {         return super.onStartCommand(intent, flags, startId);     }      @Override     public void onDestroy() {         super.onDestroy();     }      远程Service向Client提供的服务,接口方法add()和minus()实现由Service决定     private ICalculator.Stub mBinder = new ICalculator.Stub() {         @Override         public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,                  double aDouble, String aString) throws RemoteException {          }          @Override         public int add(int a, int b) throws RemoteException {             return a + b;         }          @Override         public int minus(int a, int b) throws RemoteException {             return a - b;         }     };  }  //AndroidManifest中Service组件声明,由于是Client工程不能显示调用远程Service,只能采用隐式调用的方     式,因此需要填写category和action <service     android:name=".CalculatorService"     android:enabled="true"     android:exported="true"     android:process=":remote">     <intent-filter>         <category android:name="android.intent.category.DEFAULT"/>         <action android:name="com.wangxinghe.ipc_server.CalculatorService"/>     </intent-filter> </service> 

(3)在Client工程中,拷贝以上.aidl文件及目录,使用Service提供的服务。

//远程Service连接回调 private ServiceConnection mServiceConnection = new ServiceConnection() {     @Override     public void onServiceConnected(ComponentName name, IBinder service) {         //连接成功,获取远程Service的Binder         mCalculator = ICalculator.Stub.asInterface(service);     }      @Override     public void onServiceDisconnected(ComponentName name) {         mCalculator = null;     } };  @Override public void onClick(View v) {     switch (v.getId()) {         case R.id.bind_service:             //绑定服务             Intent intent = new Intent(ACTION_CALCULATOR_SERVICE);             bindService(intent, mServiceConnection, BIND_AUTO_CREATE);             break;         case R.id.unbind_service:             //断开服务             unbindService(mServiceConnection);             break;         case R.id.add:             //调用远程服务的add()             int result = 0;             try {                 if (mCalculator != null) {                     result = mCalculator.add(2, 1);                 }             } catch (RemoteException e) {                 e.printStackTrace();             }             mResultTv.setText(result + "");             break;         case R.id.minus:             //调用远程服务的minus()             int _result = 0;             try {                 if (mCalculator != null) {                     _result = mCalculator.minus(2, 1);                 }             } catch (RemoteException e) {                 e.printStackTrace();             }             mResultTv.setText(_result + "");             break;     } } 

###(4)启动Client和Service工程,即可实现进程间通信。

4. 原理分析

由于 Binder 机制涉及的东西很多。学姐本文并不打算深入到内核源码,关于Client是怎样获取到远程Binder的会在后续文章再讲述。下面主要是从应用层角度分析。

我们先看看ICalculator.aidl编译生成的ICalculator.java文件。

package me.wangxinghe.ipc; // Declare any non-default types here with import statements  public interface ICalculator extends android.os.IInterface {          /** Local-side IPC implementation stub class. */     public static abstract class Stub extends android.os.Binder implements          me.wangxinghe.ipc.ICalculator     {         //接口描述符         private static final java.lang.String DESCRIPTOR = "me.wangxinghe.ipc.ICalculator";                  /** Construct the stub at attach it to the interface. */         public Stub()         {             //添加Binder和接口描述符到该Binder中,便于后续本地查找Binder             this.attachInterface(this, DESCRIPTOR);         }                  /**          * Cast an IBinder object into an me.wangxinghe.ipc.ICalculator interface,          * generating a proxy if needed.          */         public static me.wangxinghe.ipc.ICalculator asInterface(android.os.IBinder obj)         {             if ((obj==null)) {                 return null;             }                          //根据接口描述符,从Binder中查找对应的接口,若有则直接返回             android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);             if (((iin!=null)&&(iin instanceof me.wangxinghe.ipc.ICalculator))) {                 return ((me.wangxinghe.ipc.ICalculator)iin);             }                          //否则返回接口的代理对象,并将远端Binder传入代理             return new me.wangxinghe.ipc.ICalculator.Stub.Proxy(obj);         }                  @Override          public android.os.IBinder asBinder()         {             //返回Binder             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_basicTypes:                 {                     data.enforceInterface(DESCRIPTOR);                     int _arg0;                     _arg0 = data.readInt();                     long _arg1;                     _arg1 = data.readLong();                     boolean _arg2;                     _arg2 = (0!=data.readInt());                     float _arg3;                     _arg3 = data.readFloat();                     double _arg4;                     _arg4 = data.readDouble();                     java.lang.String _arg5;                     _arg5 = data.readString();                     this.basicTypes(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5);                     reply.writeNoException();                     return true;                 }                 case TRANSACTION_add:                 {                     //解析data Parcel参数,执行具体的加法操作,并将计算结果写进reply Parcel                     //add()由Service实现                     data.enforceInterface(DESCRIPTOR);                     int _arg0;                     _arg0 = data.readInt();                     int _arg1;                     _arg1 = data.readInt();                     int _result = this.add(_arg0, _arg1);                     reply.writeNoException();                     reply.writeInt(_result);                     return true;                 }                 case TRANSACTION_minus:                 {                     //解析data Parcel参数,执行具体的减法操作,并将计算结果写进reply Parcel                     //minus()由Service实现                     data.enforceInterface(DESCRIPTOR);                     int _arg0;                     _arg0 = data.readInt();                     int _arg1;                     _arg1 = data.readInt();                     int _result = this.minus(_arg0, _arg1);                     reply.writeNoException();                     reply.writeInt(_result);                     return true;                 }             }             return super.onTransact(code, data, reply, flags);         }                  //代理类         private static class Proxy implements me.wangxinghe.ipc.ICalculator         {             //远程Binder             private android.os.IBinder mRemote;                          Proxy(android.os.IBinder remote)             {                 mRemote = remote;             }                          @Override             public android.os.IBinder asBinder()             {                 //返回远程Binder                 return mRemote;             }                          public java.lang.String getInterfaceDescriptor()             {                 //返回接口描述符                 return DESCRIPTOR;             }                          /**              * Demonstrates some basic types that you can use as parameters              * and return values in AIDL.              */             @Override             public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,              double aDouble, java.lang.String aString) throws android.os.RemoteException             {                 android.os.Parcel _data = android.os.Parcel.obtain();                 android.os.Parcel _reply = android.os.Parcel.obtain();                 try {                     _data.writeInterfaceToken(DESCRIPTOR);                     _data.writeInt(anInt);                     _data.writeLong(aLong);                     _data.writeInt(((aBoolean)?(1):(0)));                     _data.writeFloat(aFloat);                     _data.writeDouble(aDouble);                     _data.writeString(aString);                     mRemote.transact(Stub.TRANSACTION_basicTypes, _data, _reply, 0);                     _reply.readException();                 } finally {                     _reply.recycle();                     _data.recycle();                 }             }                          @Override             public int add(int a, int b) throws android.os.RemoteException             {                 //执行加法操作,将接口描述符和参数封装进data Parcel,调用远程Binder执行加法操作,                          //并从reply Parcel中解析出结果,返回结果。该过程是同步操作                 android.os.Parcel _data = android.os.Parcel.obtain();                 android.os.Parcel _reply = android.os.Parcel.obtain();                 int _result;                 try {                     _data.writeInterfaceToken(DESCRIPTOR);                     _data.writeInt(a);                     _data.writeInt(b);                     mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);                     _reply.readException();                     _result = _reply.readInt();                 } finally {                     _reply.recycle();                     _data.recycle();                 }                 return _result;             }                          @Override              public int minus(int a, int b) throws android.os.RemoteException             {                 //执行减法操作,将接口描述符和参数封装进data Parcel,调用远程Binder执行减法操作,                 //并从reply Parcel中解析出结果,返回结果。该过程是同步操作                 android.os.Parcel _data = android.os.Parcel.obtain();                 android.os.Parcel _reply = android.os.Parcel.obtain();                 int _result;                 try {                     _data.writeInterfaceToken(DESCRIPTOR);                     _data.writeInt(a);                     _data.writeInt(b);                     mRemote.transact(Stub.TRANSACTION_minus, _data, _reply, 0);                     _reply.readException();                     _result = _reply.readInt();                 } finally {                     _reply.recycle();                     _data.recycle();                 }                 return _result;             }         }              static final int TRANSACTION_basicTypes = (android.os.IBinder.FIRST_CALL_TRANSACTION +          0);         static final int TRANSACTION_add = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);         static final int TRANSACTION_minus = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);     }      /**      * Demonstrates some basic types that you can use as parameters      * and return values in AIDL.      */     public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double      aDouble, java.lang.String aString) throws android.os.RemoteException;      //接口方法     public int add(int a, int b) throws android.os.RemoteException;      //接口方法     public int minus(int a, int b) throws android.os.RemoteException; } 

基本使用 部分,我们可以看到,Client在与Service建立连接成功后,会拿到远程Binder实例(此处不能直接使用远程Binder原因还不是很清楚),并调用Stub的asInterface方法将其转换成ICalculator接口。

mCalculator = ICalculator.Stub.asInterface(service); 

这一步执行的操作是:根据接口描述符,从Binder中本地查找对应的接口,若有则直接返回;否则,将Binder对象传给本地代理Stub.Proxy对象,并返回本地代理,由本地代理来接管相应的服务,Proxy也实现了ICalculator接口。

这一步之后,Client就可以使用远程Service提供的服务了。

再看看onClick()事件中的加法操作。

result = mCalculator.add(2, 1); 

mCalculator即为上面得到的本地代理对象,其add()的实现是

@Override  public int add(int a, int b) throws android.os.RemoteException {     android.os.Parcel _data = android.os.Parcel.obtain();     android.os.Parcel _reply = android.os.Parcel.obtain();     int _result;     try {         _data.writeInterfaceToken(DESCRIPTOR);         _data.writeInt(a);         _data.writeInt(b);         mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);         _reply.readException();         _result = _reply.readInt();     }     finally {         _reply.recycle();         _data.recycle();     }     return _result; } 

可以看到实际上是调用连接建立成功后的远程Binder的transact(add)方法。再看看Binder.transact实现

public final boolean transact(int code, Parcel data, Parcel reply,         int flags) throws RemoteException {     if (false) Log.v("Binder", "Transact: " + code + " to " + this);     if (data != null) {         data.setDataPosition(0);     }     boolean r = onTransact(code, data, reply, flags);     if (reply != null) {         reply.setDataPosition(0);     }     return r; } 

可以看到最后调用了远程Binder的onTransact()方法,也就是走到了远程Binder的Stub.onTransact()方法。这个方法实现是

@Override  public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags)  throws android.os.RemoteException {     switch (code)     {         case TRANSACTION_add:         {             data.enforceInterface(DESCRIPTOR);             int _arg0;             _arg0 = data.readInt();             int _arg1;             _arg1 = data.readInt();             int _result = this.add(_arg0, _arg1);             reply.writeNoException();             reply.writeInt(_result);             return true;         }         ...     } } 

这里最终调用到了远程Service工程创建的ICalculator.Stub实例mBinder的add()方法即a+b,因此得到了最后的结果。

好了,我们再来梳理下,Client获得并使用Service服务的过程:

(1)Client与Service建立连接,得到远程Binder(这个Binder就是Service的onBind返回的Binder,但是客户端不能直接使用,具体原因还不是很明确)。

(2)将远程Binder传给本地代理,得到本地代理Stub.Proxy实例。

(3)通过本地代理Stub.Proxy实例间接调用远程Binder对象的add()方法。 具体实现是:由于远程Binder已经传给了本地代理Stub.Proxy。那么通过本地代理Stub.Proxy实例间接调用远程Binder的transact(TRANSACTION_add)操作;调用远程Binder的onTransact()方法;调用远程Binder的实现类ICalculator.Stub的add()方法

(4)得到结果

下面再总结下 ICalculatorStubProxy 这3个类的关系:

ICalculator :就是一个接口类。内部包括之前的接口方法和静态Stub类。

Stub :远程Binder实现类。继承类 BinderICalculator 接口。

Proxy :远程Binder代理类。实现 ICalculator 接口。

5. 总结

(1)Binder相当于不同进程间数据通信的通道

(2)核心是代理模式,使用本地代理Proxy操作远端Binder,使用相应服务

(3)如理解有误,欢迎指正

6. 参考链接

(1) http://blog.csdn.net/singwhatiwanna/article/details/19756201

(2) http://blog.csdn.net/luoshengyang/article/details/6618363

欢迎大家关注我的公众号:学姐的IT专栏

Android进程间通信机制Binder应用层分析

转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » Android进程间通信机制Binder应用层分析

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址
分享按钮