【Android源码】Binder机制和AIDL分析

通常情况下，如果两个对象能够直接相互访问，那么这两个对象存在于同一个内存空间中。
如果两个对象分别存在于两个不同的进程的时候，那么这两个对象是不能相互访问的，这个时候就需要使用跨进程通信的技术了。
而Android是基于Linux系统的，Linux传统的跨进程技术主要是Socket，信号量，管道，消息队列等，但是这些技术都有不同的缺点，如Socket开销大效率不高，管道和消息队列拷贝次数多，而对于Android系统来讲，更重要的是安全性要高，而这些技术安全性都不是很高，大部分情况下接收方并不能得到发送发进程的PID/UID，很难识别身份。
所以Android系统就设计出了Binder跨进程通信机制，来保证传输性能和安全性。

Binder

Binder主要模块

Binder主要模块
Binder主要模块

  1. BinderDriver

    存在于内核空间中，以字符设备的misc类型注册，用户可以从/dev/binder设备文件节点上，通过open和ioctl文件操作函数与BinderDriver进行通信，主要是负责Binder通信的建立，进程间的传递、Binder引用计数管理/数据包的管理。

  2. BinderClient

    存在于用户空间中，它和BinderServer的跨进程通信都是通过BinderDriver来处理转发的。
    对于BinderClient只需要知道自己需要使用的Binder的名字和该Binder在ServerManager中的0号引用就可以了。通过0号引用去访问ServerManager获取Binder的引用，得到引用后就可以直接调用Binder的方法了。

  3. ServerManager

    存在于用户空间中，用来管理BinderServer，BinderClient可以通过它来查询BinderServer接口，查询到之后就可以获取到Binder的映射。

  4. BinderServer

    BinderServer会生成一个Binder实体，并会给Binder绑定一个名字，最终封装成一个数据包传递给BinderDriver，BinderDriver在获取到这个数据包之后，如果发现这个数据包是新传递过来的，就会给其在内核空间中创建相应的Binder实体节点和对应的实体节点的引用。
    BinderDriver会将Binder的引用传递给ServerManager，ServerManager收到后就会取出Binder的名字和引用插入一张数据表中，这个就和DNS存储域名到IP的映射原理一样。

系统如何使用Binder

在客户端中ServerManager的接口定义主要是在IServiceManager中：

public interface IServiceManager extends IInterface
{
    /**
     * Retrieve an existing service called @a name from the
     * service manager.  Blocks for a few seconds waiting for it to be
     * published if it does not already exist.
     */
    public IBinder getService(String name) throws RemoteException;
    
    /**
     * Retrieve an existing service called @a name from the
     * service manager.  Non-blocking.
     */
    public IBinder checkService(String name) throws RemoteException;

    /**
     * Place a new @a service called @a name into the service
     * manager.
     */
    public void addService(String name, IBinder service, boolean allowIsolated)
                throws RemoteException;

    /**
     * Return a list of all currently running services.
     */
    public String[] listServices() throws RemoteException;

    /**
     * Assign a permission controller to the service manager.  After set, this
     * interface is checked before any services are added.
     */
    public void setPermissionController(IPermissionController controller)
            throws RemoteException;
    
    static final String descriptor = "android.os.IServiceManager";

    int GET_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION;
    int CHECK_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+1;
    int ADD_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+2;
    int LIST_SERVICES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+3;
    int CHECK_SERVICES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+4;
    int SET_PERMISSION_CONTROLLER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+5;
}

可以看到IServiceManager定义的方法主要是添加，获取，检查等关于各种服务。主要作用其实就是像上面所说的简单的将Binder以字符表示的名字转换成引用。而对于BinderClient的实现其实就是ServiceManagerNative和ServiceManagerProxy，这两个类实现了该接口，我们在AIDL的时候在分析。

AIDL

我们以具体的例子来分析，首先我们创建相关aidl文件：

// Book.java
public class Book implements Parcelable {
    public int bookId;
    public String bookName;

    protected Book(Parcel in) {
        bookId = in.readInt();
        bookName = in.readString();
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(bookId);
        dest.writeString(bookName);
    }

    @Override
    public int describeContents() {
        return 0;
    }

    public static final Creator<Book> CREATOR = new Creator<Book>() {
        @Override
        public Book createFromParcel(Parcel in) {
            return new Book(in);
        }

        @Override
        public Book[] newArray(int size) {
            return new Book[size];
        }
    };
}

// Book.aidl
package com.fastaoe.proficient;
parcelable Book;

// IBookManager.aidl
package com.fastaoe.proficient;

import com.fastaoe.proficient.Book;

interface IBookManager {
    List<Book> getBookList();
    void addBook(in Book book);
}

上面3个文件，Book.java表示图书信息，实现了Parcelable接口。
Book.aidl是Book.java在AIDL中的声明。
IBookManager是定义了用来操作Book的方法，getBookList从服务器中获取图书列表，addBook向服务器图书列表中插入一本新书。
当我们声明好了AIDL之后，IDE编译好之后，就生成了IBookManager.java这个类。

public interface IBookManager extends android.os.IInterface {
    // 代码省略，下面在分析
}

可以看到这个系统为我们生成的类，实现了IInterface这个接口，自己本身也是一个接口，我们可以实现这个接口来实现相关的方法。我们来具体分析下这个生成的接口：

private static final java.lang.String DESCRIPTOR = "com.fastaoe.proficient.IBookManager";

Binder的唯一标识，一般情况下使用当前的类来表示。

public static com.fastaoe.proficient.IBookManager asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.fastaoe.proficient.IBookManager))) {
                return ((com.fastaoe.proficient.IBookManager) iin);
            }
            return new com.fastaoe.proficient.IBookManager.Stub.Proxy(obj);
        }

用来将服务器中的Binder对象转换成客户端中所需要的AIDL接口类型的对象。可以看到当客户端和服务端在同一个进程的时候，返回的就是服务端的Stub本身，如果不在同一个进程，返回的是系统封装好的Stub.proxy对象，这表示当不在同一个进程的时候，客户端拿到的其实不是服务端Binder本身，而是一个副本。

public android.os.IBinder asBinder() {
            return this;
        }

返回Binder对象本身。

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_getBookList: {
               data.enforceInterface(DESCRIPTOR);
               java.util.List<com.fastaoe.proficient.Book> _result = this.getBookList();
               reply.writeNoException();
               reply.writeTypedList(_result);
               return true;
           }
           case TRANSACTION_addBook: {
               data.enforceInterface(DESCRIPTOR);
               com.fastaoe.proficient.Book _arg0;
               if ((0 != data.readInt())) {
                   _arg0 = com.fastaoe.proficient.Book.CREATOR.createFromParcel(data);
               } else {
                   _arg0 = null;
               }
               this.addBook(_arg0);
               reply.writeNoException();
               return true;
           }
       }
       return super.onTransact(code, data, reply, flags);
   }

这个方法运行在服务器端的Binder线程池中，当客户端发起跨进程的请求的时候，请求会通过底层封装之后交给此方法执行。服务器端通过code来判断客户端请求的方法是什么，接着从data中获取目标方法所需要的数据，并执行目标方法。当方法执行完之后通过reply写入返回值，最后返回是否成功，如果成功返回true，否则则是false失败。

private static class Proxy implements com.fastaoe.proficient.IBookManager {
       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 java.util.List<com.fastaoe.proficient.Book> getBookList() throws android.os.RemoteException {
           android.os.Parcel _data = android.os.Parcel.obtain();
           android.os.Parcel _reply = android.os.Parcel.obtain();
           java.util.List<com.fastaoe.proficient.Book> _result;
           try {
               _data.writeInterfaceToken(DESCRIPTOR);
               mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
               _reply.readException();
               _result = _reply.createTypedArrayList(com.fastaoe.proficient.Book.CREATOR);
           } finally {
               _reply.recycle();
               _data.recycle();
           }
           return _result;
       }

       @Override
       public void addBook(com.fastaoe.proficient.Book book) throws android.os.RemoteException {
           android.os.Parcel _data = android.os.Parcel.obtain();
           android.os.Parcel _reply = android.os.Parcel.obtain();
           try {
               _data.writeInterfaceToken(DESCRIPTOR);
               if ((book != null)) {
                   _data.writeInt(1);
                   book.writeToParcel(_data, 0);
               } else {
                   _data.writeInt(0);
               }
               mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
               _reply.readException();
           } finally {
               _reply.recycle();
               _data.recycle();
           }
       }
   }

这个类运行在客户端中，当客户端调用此方法之后，首先会创建parcel的类型的输入对象_data，输出对象_reply，返回值对象_result（如果有的话），接着通过_data将参数存储起来，在通过transact方法来发送RPC请求，同时线程会被挂起。接着服务端的onTransact方法会调用，最终RPC过程返回后，当前线程继续执行，从_reply获取到返回的结果。

通过AIDL实现跨进程通信（参考《Android开发艺术探索第二章例子》）

我们把AIDL生成的类分析完之后，就来实现一个服务器和客户端通信的例子吧。

首先定义AIDL文件，就是上面图书的例子

其中需要注意的是：

AIDL支持的数据类型：

  • 基本数据类型
  • String和CharSequence
  • ArrayList和HashMap
  • Parcelable
  • AIDL本身

当我们自定义了Parcelable的时候，必须新建一个同名的.aidl文件，并将其声明为parcelable类型。
AIDL中所有的实现了Parcelabe接口的类都需要声明相对应的aidl文件，并且需要标识in(输入)、out(输出)、inout(输入输出)。

服务端的实现

public class ServerService extends Service {
    
   private CopyOnWriteArrayList<Book> list = new CopyOnWriteArrayList<>();
   private RemoteCallbackList<IAddBookListener> listeners = new RemoteCallbackList<>();
    
   @Override
   public void onCreate() {
       super.onCreate();
       list.add(new Book(1, "岛上书店"));
       list.add(new Book(2, "白夜行"));
   }
    
   @Nullable
   @Override
   public IBinder onBind(Intent intent) {
       return binder;
   }
    
   private IBinder binder = new IBookManager.Stub(){
    
       @Override
       public List<Book> getListBook() throws RemoteException {
           return list;
       }
    
       @Override
       public void addBook(Book book) throws RemoteException {
           onNewBookAdd(book);
       }
    
       @Override
       public void registerListener(IAddBookListener listener) throws RemoteException {
           listeners.register(listener);
       }
    
       @Override
       public void unregisterListener(IAddBookListener listener) throws RemoteException {
           listeners.unregister(listener);
       }
   };
    
   private void onNewBookAdd(Book book) throws RemoteException {
       list.add(book);
       int N = listeners.beginBroadcast();
       for (int i = 0; i < N; i++) {
           IAddBookListener broadcastItem = listeners.getBroadcastItem(i);
           broadcastItem.OnNewBookAddListener(book);
       }
       listeners.finishBroadcast();
   }
}

在服务端中我们首先初始化了图书列表，并创建了Binder对象并在onBind中返回。

  1. 使用了CopyOnWriteArrayList，这个List是支持并发读写的，因为当多个客户端同时连接的时候，会出现多个线程同时访问的问题，所以需要在AIDL中处理线程问题。

  2. 使用RemoteCallbackList来管理跨进程的listener接口，因为如果使用List的话，并不能在unregister的时候删除掉当前listener接口，虽然我们使用的看上去是同一个listener，但是其实并不是同一个对象。

    客户端和服务端在多进程的环境中，而对象是不可能在多进程下传递的，所以Binder会将客户端传递过来的对象重新转化成新的对象，并不是原来的对象，这其实是反序列化的过程，所以AIDL中的自定义对象必须实现Parcelable接口。

    那么怎么解除注册呢？

    可以通过RemoteCallbackList，RemoteCallbackList是系统专门提供用来删除跨进程listener的接口，在它的内部有一个Map用来保存所有的AIDL回调，key是IBinder，value是callback。虽然在跨进程的环境中，生成的对象不是同一个对象，但是它们底层的Binder肯定是同一个，所以可以利用这个来实现解除注册。当客户端要解除注册的时候，服务端通过RemoteCallbackList找到具有相同Binder对象的服务端listener并将其删除。

客户端实现

public class MainActivity extends AppCompatActivity {
    
   private List<Book> list = new ArrayList<>();
    
   private int index = 3;
    
   Handler handler = new Handler(){
       @Override
       public void handleMessage(Message msg) {
           switch (msg.what) {
               case 1:
                   list.add((Book) msg.obj);
                   tv_book.setText(list.toString());
                   break;
    
           }
       }
   };
    
   private ServiceConnection conn = new ServiceConnection() {
       @Override
       public void onServiceConnected(ComponentName name, IBinder service) {
           iBookManager = IBookManager.Stub.asInterface(service);
           try {
               iBookManager.registerListener(listener);
           } catch (RemoteException e) {
               e.printStackTrace();
           }
       }
    
       @Override
       public void onServiceDisconnected(ComponentName name) {
           iBookManager = null;
       }
   };
    
   private IBookManager iBookManager;
   private IAddBookListener listener = new IAddBookListener.Stub() {
       @Override
       public void OnNewBookAddListener(Book book) throws RemoteException {
           handler.obtainMessage(1, book).sendToTarget();
       }
   };
   private Button btn_search;
   private Button btn_add;
   private TextView tv_book;
    
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
    
       btn_search = (Button) findViewById(R.id.btn_search);
       btn_add = (Button) findViewById(R.id.btn_add);
       tv_book = (TextView) findViewById(R.id.tv_book);
    
       btn_search.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {
               if (iBookManager != null) {
                   try {
                       // TODO: 2017/7/9 放在子线程中 
                       list = iBookManager.getListBook();
                   } catch (RemoteException e) {
                       e.printStackTrace();
                   }
                   tv_book.setText(list.toString());
               }
           }
       });
    
       btn_add.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {
               if (iBookManager != null) {
                   Book book = new Book(index, "图书"+ index);
                   index += 1;
                   try {
                       // TODO: 2017/7/9 放在子线程中 
                       iBookManager.addBook(book);
                   } catch (RemoteException e) {
                       e.printStackTrace();
                   }
               }
           }
       });
    
       Intent intent = new Intent();
       intent.setAction("com.fastaoe.server.ServerService");
       intent.setComponent(new ComponentName("com.fastaoe.server", "com.fastaoe.server.ServerService"));
       bindService(intent, conn, Context.BIND_AUTO_CREATE);
   }
    
   @Override
   protected void onDestroy() {
       try {
           iBookManager.unregisterListener(listener);
       } catch (RemoteException e) {
           e.printStackTrace();
       }
       unbindService(conn);
       super.onDestroy();
   }
}

首先绑定远程服务，接着将远程服务返回的Binder对象转换成AIDL接口，接着就可以调用服务端中的方法了。

  1. 需要注意的是如果aidl中的方法在服务端是耗时的操作的时候，需要处理，不然会导致ANR的产生，同样的当服务端调用客户端的耗时操作的时候，也需要保证在服务端的方法运行在非UI线程，因为Service本身是运行在UI线程中的。

  2. OnNewBookAddListener运行在Binder线程池中，所以不能在其中访问UI相关的内容，如果需要访问的话，则需要通过Handler切换线程。

  3. Binder在连接过程中是可能意外死亡的，主要是因为服务端的进程被终止了，所以我们需要重新连接服务。

    1. 可以通过在onServiceDisconnected中重连。
    2. 也可以通过DeathRecipient来监听是否被断开。

具体的Demo可以查看AIDL的简单实现

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,383评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,522评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,852评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,621评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,741评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,929评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,076评论 3赞 410
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,803评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,265评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,582评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,716评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,395评论 4赞 333
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,039评论 3赞 316
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,798评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,027评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,488评论 2赞 361
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,612评论 2赞 350

推荐阅读更多精彩内容