2.Android内核 Binder

 

   Binder,英文的意思是别针、回形针。平常我们经常用回形针把几张纸夹起来。而在Android

中，Binder用于完成进程间通信（IPC），就是把多个线程夹起来。比如，普通应用程序可以

调用音乐播放服务的播放、暂停、停止等功能。

   Binder工作在Linux层面，属于一个驱动，只是这个驱动不需要硬件，或者说Binder操作的硬

件是基于一小段内存。从线程的角度来讲，Binder驱动代码运行在内核态，客户端程序调用Binder

是通过系统调用完成的。

Binder框架

   Binder是一种架构，这种架构提供了服务端接口、Binder驱动、客户端接口三个模块，如下图 ：

   首先来看服务端。一个Binder服务端实际上就是一个Binder类的对象，该对象一旦创建，内部就

启动一个隐藏线程。该线程接下来会接收Binder驱动发送的消息，收到消息后，会执行到Binder对

象中的onTransact()函数，并按照该函数的参数执行不同的服务代码。因此，要实现一个Binder服

务，就必须重载onTransact()方法。

   可以想象，重载onTransact()函数的主要内容是把onTransact()函数的参数转换为服务函数的参数

而onTransact()函数的参数来源是客户端调用transact()函数时输入的，因此，如果transact()有固定

格式的输入，那么onTransact()就会有固定格式的输出。

   那再看Binder驱动。任意一个服务端Binder对象被创建时，同时会在Binder驱动中创建一个mRemote

对象，该对象的类型也是Binder类。客户端访问远程服务时，都是通过mRemote对象。

   最后来看应用程序客户端。客户端要想访问远程服务，必须获取远程服务在Binder对象中对应的mRemote

引用。获取该mRemote对象后，就可以调用其transact()方法，而在Binder驱动中，mRemote对象也重载了

transact()方法，重载的内容包括以下几项：

1.以线程间消息通信的模式，向服务端发送客户端传递过来的参数。

        2.挂起当前线程，当前线程正是客户端线程，并等待服务端线程执行完指定服务函数后通知(notify)。

3.接收服务端线程的通知，然后继续执行客户端线程，并返回到客户端代码区。

   以上可以得出，客户端似乎是直接调用远程服务对应的Binder，而事实上则是通过Binder驱动进行

了中转。即存在两个Binder对象，一个是服务端的Binder对象，另一个则是Binder驱动中的Binder对

象，所不同的是Binder驱动中的对象不会再额外产生一个线程。

   那么，我们来看看Android Binder的源代码：

    /**     * Default constructor initializes the object.     */    public Binder() {        init();        if (FIND_POTENTIAL_LEAKS) {            final Class<? extends Binder> klass = getClass();            if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&                    (klass.getModifiers() & Modifier.STATIC) == 0) {                Log.w(TAG, "The following Binder class should be static or leaks might occur: " +                    klass.getCanonicalName());            }        }    }

    private native final void init();    private native final void destroy();

   这两段代码可以看出，在Binder的构造函数中，执行了init()方法。通过JNI的形式调用了底层C

的init()函数，内部就完成了"启动隐藏线程"。 

    /**     * Default implementation is a stub that returns false.  You will want     * to override this to do the appropriate unmarshalling of transactions.     *     * <p>If you want to call this, call transact().     */    protected boolean onTransact(int code, Parcel data, Parcel reply,            int flags) throws RemoteException {        if (code == INTERFACE_TRANSACTION) {            reply.writeString(getInterfaceDescriptor());            return true;        } else if (code == DUMP_TRANSACTION) {            ParcelFileDescriptor fd = data.readFileDescriptor();            String[] args = data.readStringArray();            if (fd != null) {                try {                    dump(fd.getFileDescriptor(), args);                } finally {                    try {                        fd.close();                    } catch (IOException e) {                        // swallowed, not propagated back to the caller                    }                }            }            // Write the StrictMode header.            if (reply != null) {                reply.writeNoException();            } else {                StrictMode.clearGatheredViolations();            }            return true;        }        return false;    }

    /**     * Default implementation rewinds the parcels and calls onTransact.  On     * the remote side, transact calls into the binder to do the IPC.     */    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;    }

   这两段代码可以看出，onTransact中主要对data进行了处理，即把onTranSact()函数的参数转换

为服务函数的参数；而在transact中调用了onTransact()函数也恰巧说明了：transact()有固定格式的

输入，那么onTransact()就会有固定格式的输出。

简单实现Binder架构

设计Server端

设计Server端实际上非常简单，从代码的角度而言，只要基于Binder类新建一个Server类即可。

MusicPlayerService:

package com.zyy.android_csdn.skill;import android.os.Binder;import android.os.Parcel;import android.os.RemoteException;import android.util.Log;/** *  * 请叫我"Server端" *  * @author CaMnter *  */public class MusicPlayerServiceBinder extends Binder implementsIMusicPlayerService {@Overrideprotected boolean onTransact(int code, Parcel data, Parcel reply, int flags)throws RemoteException {switch (code) {case 1000:// enforceInterface为了校验 与客户端的writeInterfaceToken()对应data.enforceInterface("MusicPlayerService");// data 中读取客户端传递的参数String filePath = data.readString();/* * 如果该IPC调用的客户端期望返回一些结果，则可以在返回包裹reply 中调用Parcel提供的相关函 数写入相应的结果 */// reply.writeXXX()start(filePath);break;default:break;}return super.onTransact(code, data, reply, flags);}public void start(String filePath) {Log.i("CaMnter", filePath);}public void stop() {}}

IMusicPlayerService：

package com.zyy.android_csdn.skill;/** *  * 请叫我 "MusicPlayerService 标识接口" *  * @author CaMnter *  */public interface IMusicPlayerService {}

   以上定义了服务类，重载了Binder的onTransact()方法，code变量用于标识客户端期望调用服务端

的哪个函数，因此，双方需要约束一组int值，不同的值代表不同的服务端函数，该值和客户端的transact()

函数中的第一个参数code是一致的。这里假定1000是双方约束要调用start函数的值。

   enforceInterface()是为了某种校验，与客户端的writeInterfaceToken()对应。

   readString()用于从包裹中取出一个字符串。取出filePath变量后，就可以调用服务端的start()函数。

   如果该IPC调用的客户端期望返回一些结果，我们则可以再返回包裹reply中调用Parcel提供的相关函数写入相应的方法

设计Binder 客户端

   要想使用服务端（MusicPlayerServiceBinder）,首先要获取服务端在Binder驱动中对应的

mRemote变量的引用，获取的方法在以后的会讲到，这里我们就 new MusicPlayerServiceBinder()

出来代替mRemote，合情合理的，因为mRemote也同属于IBinder类型。这个不多提，获得这个

mRemote后，就可以调用mRemote的transact()方法，该方法的函数原型就让我们参照一下Binder

的部分源代码吧：

    /**     * Default implementation rewinds the parcels and calls onTransact.  On     * the remote side, transact calls into the binder to do the IPC.     */    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;    }

   final的"终结"方法。其中data表示要传递给远程Binder的包裹（Parcel），远程服务函数所需要的

参数必须放入这个Parcel data 里。Parcel中只能放入一些特定类型的变量，这些类型有：String、int

、long等，要查看Parcel可以放入的全部数据类型，可以参照一下Parcel类。当然值得一提的是，Parcel

还提供了一个writeParcel()方法，可以再Parcel中包含一个小包裹（Parcel）。因此，要进行Binder远程

服务调用时，服务函数的参数要么是一个原子类，要么必须继承Parcel类。否则，不能传递。

接下来，我做了一个简单的实现，直观上就是客户端调用了mRemote.transact()：

package com.zyy.android_csdn.skill;import android.app.Service;import android.content.Intent;import android.os.IBinder;import android.os.Parcel;import android.os.RemoteException;/** *  * 请叫我"Binder 客户端" *  * @author CaMnter *  */public class MusicPlayerService extends Service implements IMusicPlayerService {private MusicPlayerServiceBinder musicPlayerServiceBinder = new MusicPlayerServiceBinder();@Overridepublic IBinder onBind(Intent intent) {return this.musicPlayerServiceBinder;}public MusicPlayerService() {super();this.startTransact();}public void startTransact() {IBinder mRemote = musicPlayerServiceBinder;String filePath = "/sdcard/music/helloword.mp3";int code = 1000;Parcel data = Parcel.obtain();Parcel reply = Parcel.obtain();data.writeInterfaceToken("MusicPlayerService");data.writeString(filePath);try {mRemote.transact(code, data, reply, 0);} catch (RemoteException e) {e.printStackTrace();}reply.recycle();data.recycle();}}

   以上代码。首先，Parcel类型的data、reply不是客户端自己创建的，而是调用Parcel.obtain()申请

的， 这正如生活中的邮局一样，用户一般只能用邮局提供的信封（EMS）。其中data和reply变量都是

由客户端提供，reply变量用户客户端把返回结果放入其中。

   writeInterfaceToken()方法标注远程服务名称，理论上而言，这个名称不是必需的，因为客户端既然

已经获取指定远程服务的Binder引用（这里我IBinder mRemote = musicPlayerServiceBinder; 来模拟

获取过程），那么就不会调用到其他远程服务。该名称将作为Binder驱动确保客户端的确想调用指定的服

务端。

   writeString()方法用于向Parcel类型中添加一个String变量。注意，Parcel中添加的内容是有序的，这个

顺序必须是客户端和服务端事先约束好的，在服务端onTransact方法中会按照约定的顺序取出变量。

   接着，mRemote.transact(code, data, reply, 0)。调用transact()方法，客户端线程进入了Binder驱动

Binder驱动会挂起当前的线程(客户端线程)，并向远程服务发送一个消息，消息中包含了客户端传来的包裹

（Parcel）。服务端拿到包裹（Parcel）后，会对包裹（Parcel）进行拆解，然后执行指定的服务函数，执

行完毕后，再将执行完毕后的执行结果放入客户端提供的reply包裹（Parcel）中。然后服务端想Binder驱动

发送一个notify的消息，从而使得客户端线程从Binder驱动代码区返回到客户端代码区。

再看：

    /**     * Default implementation rewinds the parcels and calls onTransact.  On     * the remote side, transact calls into the binder to do the IPC.     */    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;    }

   可以发现transact()方法的最后一个参数是 int flags。这个flags参数的含义是执行IPC调用的模式，分为

两种：一种 0 表示 双向的，其含义表示服务端执行完指定服务后会返回一定的数据；另一张 1 表示 单向的，其

含义是不返回任何数据。

   最后，客户端（我这的是MusicPlayerService）就可以从reply中解析服务端（我这的是MusicPlayerServiceBinder）

返回的数据了，同样，返回包裹中包含的数据也必须是有序的，而且这个顺序也必须是服务端和客户端事先约定好的。

绑定服务，实现Binder架构

BinderActivity:

package com.zyy.android_csdn;import com.zyy.android_csdn.skill.IMusicPlayerService;import android.support.v7.app.ActionBarActivity;import android.content.ComponentName;import android.content.Intent;import android.content.ServiceConnection;import android.os.Bundle;import android.os.IBinder;import android.util.Log;import android.view.Menu;import android.view.MenuItem;public class BinderActivity extends ActionBarActivity {/** *  * onServiceConnected(ComponentName name, IBinder service)中的 service保存为一个全局变量 *  *  * 从而在客户端的任何地方都可以随时调用该远程服务 这就解决了第一个重要问题 *  *  * 即客户端如何 获取远程服务的Binder引用。 *  *  */public static IMusicPlayerService iMusicPlayerService;private ServiceConnection serviceConnection = new ServiceConnection() {@Overridepublic void onServiceDisconnected(ComponentName name) {}@Overridepublic void onServiceConnected(ComponentName name, IBinder service) {/** *  * 保存这个IBinder *  */BinderActivity.iMusicPlayerService = (IMusicPlayerService) service;Log.i("CaMnter", iMusicPlayerService.getClass().hashCode() + "");}};@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.adapter);new Thread("CaMnterThread") {@Overridepublic void run() {BinderActivity.this.bindService(new Intent("com.zyy.MusicPlayerService"),BinderActivity.this.serviceConnection,BIND_AUTO_CREATE);}}.start();}@Overridepublic boolean onCreateOptionsMenu(Menu menu) {getMenuInflater().inflate(R.menu.main, menu);return true;}@Overridepublic boolean onOptionsItemSelected(MenuItem item) {int id = item.getItemId();if (id == R.id.action_settings) {return true;}return super.onOptionsItemSelected(item);}}

   这里就是用一个ServiceConnection取出了Binder类型然后转成标识接口IMusicPlayerService，接着就是

绑定服务了。

  我们可以看到 "/sdcard/music/helloword.mp3" 证明了一个简单的Binder架构已经实现了。

ServiceConnection里的学问和技巧

   请注意，onServiceConnected()的第二个变量service。当客户端请求AmS（ActivityManagerService）

启动某个服务（Service）后，该服务（Service）如果正常启动，那么Ams（ActivityManagerService）就

会远程调用Ams（ActivityManagerService）就会调用ActivityThread类中的ApplicationThread对象，调用

的参数中会包含服务（Service）的Binder引用，然后ApplicationThread中会回调bindService中的ServiceConnection接口

（这里我的是 BinderActivity.this.serviceConnection）。因此，在客户端中，可以再onServiceConnected()

方法中将第二个变量service保存为一个全局变量（这里我做了 BinderActivity.iMusicPlayerService = (IMusicPlayerService) service;）

从而客户端的任何地方都可以随时调用该远程服务。这就解决了第一个重要问题，就是客户端如何获取远程服务的Binder引用。

   客户端 -> Ams(ActivityManagerService) -> 调用ActivityThread类中的ApplicationThread（参数包含Binder引用）

   -> 回调bindService的ServiceConnection

Binder和AIDL

   关于第二个问题，Android的SDK中提供了一个aidl工具，该工具可以把一个aidl文件转换为一
个Java类文件，在该Java类文件，同时重载了 transact和onTransactO方法，统一 了存入包裹和

读取包裹参数，从而使设计者可以把注意力放到服务代码本身上。

可以首先编写一个IMusicPlayerServiceAIDL.aidl：

package com.zyy.android_csdn.skill;interface IMusicPlayerServiceAIDL{boolean start(String filePath);void stop();}

   aidl文件的语法基本类似于Java，package指定输出后的Java文件对应的包名。如果该文件需要引
用其他Java类，则可以使用import关键字，但需要注意的是，包裹（Parcel，这里指的是 String filePath

 属于原子型）内只能写入以下三个类型的内容。

• Java原子类型，如int、long、String等变量。
• Binder 引用。
• 实现了 Parcelable的对象。

   接下来，我们看看该aidl生成的IMusicPlayerService.java文件的代码：

/* * This file is auto-generated.  DO NOT MODIFY. * Original file: D:\\git-camnter\\CaMnter_CSDN\\src\\com\\zyy\\android_csdn\\skill\\IMusicPlayerServiceAIDL.aidl */package com.zyy.android_csdn.skill;public interface IMusicPlayerServiceAIDL extends android.os.IInterface {/** Local-side IPC implementation stub class. */public static abstract class Stub extends android.os.Binder implementscom.zyy.android_csdn.skill.IMusicPlayerServiceAIDL {private static final java.lang.String DESCRIPTOR = "com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL";/** Construct the stub at attach it to the interface. */public Stub() {this.attachInterface(this, DESCRIPTOR);}/** * Cast an IBinder object into an * com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL interface, * generating a proxy if needed. */public static com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL asInterface(android.os.IBinder obj) {if ((obj == null)) {return null;}android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);if (((iin != null) && (iin instanceof com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL))) {return ((com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL) iin);}return new com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL.Stub.Proxy(obj);}@Overridepublic android.os.IBinder asBinder() {return this;}@Overridepublic 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_start: {data.enforceInterface(DESCRIPTOR);java.lang.String _arg0;_arg0 = data.readString();boolean _result = this.start(_arg0);reply.writeNoException();reply.writeInt(((_result) ? (1) : (0)));return true;}case TRANSACTION_stop: {data.enforceInterface(DESCRIPTOR);this.stop();reply.writeNoException();return true;}}return super.onTransact(code, data, reply, flags);}private static class Proxy implementscom.zyy.android_csdn.skill.IMusicPlayerServiceAIDL {private android.os.IBinder mRemote;Proxy(android.os.IBinder remote) {mRemote = remote;}@Overridepublic android.os.IBinder asBinder() {return mRemote;}public java.lang.String getInterfaceDescriptor() {return DESCRIPTOR;}@Overridepublic boolean start(java.lang.String filePath)throws android.os.RemoteException {android.os.Parcel _data = android.os.Parcel.obtain();android.os.Parcel _reply = android.os.Parcel.obtain();boolean _result;try {_data.writeInterfaceToken(DESCRIPTOR);_data.writeString(filePath);mRemote.transact(Stub.TRANSACTION_start, _data, _reply, 0);_reply.readException();_result = (0 != _reply.readInt());} finally {_reply.recycle();_data.recycle();}return _result;}@Overridepublic void stop() throws android.os.RemoteException {android.os.Parcel _data = android.os.Parcel.obtain();android.os.Parcel _reply = android.os.Parcel.obtain();try {_data.writeInterfaceToken(DESCRIPTOR);mRemote.transact(Stub.TRANSACTION_stop, _data, _reply, 0);_reply.readException();} finally {_reply.recycle();_data.recycle();}}}static final int TRANSACTION_start = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);static final int TRANSACTION_stop = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);}public boolean start(java.lang.String filePath)throws android.os.RemoteException;public void stop() throws android.os.RemoteException;}

以上代码主要完成了三件事：

定义一个Java Interface，内部包含aidl文件所声明的服务函数，类名字为IMusicPlayerServiceAIDL

并且该类基于Ilnterface接口，即需要提供一个asBinder()函数。

定义一个Proxy类，该类将作为客户端程序访问服务端的代理。所谓的代理主要就是为了前面所提到的

第二个重要问题——统一包裹（Parcel）内写入参数的顺序。

定义一个Stub类，这是一个 abstract 类，基于Binder类，并且实现了IMusicPlayerServiceAIDL接口，

主要由服务端来使用。该类之所以要定义为一个abstract类，是因为具体的服务函数必须由程序员实现，因此

，IMusicPlayerServiceAIDL接口里定义的函数在Stub类中可以没有具体的实现。同时，在Stub类中重载了

onTransact()方法，由于transact()方法内部给包裹（Parcel）内写入参数的顺序是由aidl工具定义的，也因此

aidl工具自然知道应该按照何种顺序从包裹（Parcel）中取出相应的参数。

   在Stub类中还定义了一些int常量，比如TRANSACTION_start，这些常量与服务函数对应，transact()
和onTransactO方法的第一个参数code的值即来源于此。

   在Stub类中，除了以上所述的任务外，Stub还提供了一个asInterface()函数。提供这个函数的作用是

这样的：首先需要明确的是，aidl所产生的代码完全可以由应用程序员手工编写，IMusicPlayerServiceAIDL

中的函数只是一种编码习惯而已，aslnterface即如此，提供这个函数的原因是：服务端提供的服务除了其他

进程可以使用外（前者），在服务进程内部的其他类可以使用该服务（后者），对于后者，显然是不需要经

过IPC调用的，而可以直接在进程内部调用的，而Binder内部有一个queryLocallnterface (String description) 

函数，那么，我们顺便来看一看Binder内的这部分关于queryLocallnterface (String description) 的源代码：

       /**     * Use information supplied to attachInterface() to return the     * associated IInterface if it matches the requested     * descriptor.     */    public IInterface queryLocalInterface(String descriptor) {        if (mDescriptor.equals(descriptor)) {            return mOwner;        }        return null;    }

        /**     * Convenience method for associating a specific interface with the Binder.     * After calling, queryLocalInterface() will be implemented for you     * to return the given owner IInterface when the corresponding     * descriptor is requested.     */    public void attachInterface(IInterface owner, String descriptor) {        mOwner = owner;        mDescriptor = descriptor;    }

    /* mObject is used by native code, do not remove or rename */    private long mObject;    private IInterface mOwner;    private String mDescriptor;

   以上的三段代码可以看出，queryLocallnterface根据输入的字符串判断该Binder对象时一个本地的Binder

引用。我们再看看如下图所示：

   当创建一个Binder对象时，服务端进程内部创建一个Binder对象，Binder驱动中也会创建一个Binder

对象。如果从远程获取服务端的Binder，则只会返回Binder驱动中的的Binder对象，而如果从服务端内

部获取Binder对象的话，则会获取服务端本身的Binder对象

   再结合aidl生成的asInterface()的源码：

/** * Cast an IBinder object into an * com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL interface, * generating a proxy if needed. */public static com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL asInterface(android.os.IBinder obj) {if ((obj == null)) {return null;}android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);if (((iin != null) && (iin instanceof com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL))) {return ((com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL) iin);}return new com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL.Stub.Proxy(obj);}

   我可以看到这句：android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR)。调用了

queryLocalInterface()方法，asInterface()提供了一个统一的接口。无论是远程客户端还是本地端，当

获取Binder对象后，可以把获取的Binder对象作为asInterface()的参数，从而返回一个IMusicPlayerServicAIDL

接口。又可以从return new com.zyy.android_csdn.skill.IMusicPlayerServiceAIDL.Stub.Proxy(obj）中看

出，该接口要么使用Proxy类，要么直接使用Stub所实现的相应服务函数。

那么问题来了!

    我们经常使用的getSystemService(String serviceName)方法获取一个系统服务，那么这些系统服务的

Binder引用时如何传递给客户端?

请关注我的 3.Android ServiceManager 篇