在前面几篇文章中,我们详细介绍了Android系统进程间通信机制Binder的原理,并且深入分析了系统提供的Binder运行库和驱动程序的源代码。细心的读者会发现,这几篇文章分析的Binder接口都是基于C/C++语言来实现的,但是我们在编写应用程序都是基于Java语言的,那么,我们如何使用Java语言来使用系统的Binder机制来进行进程间通信呢?这就是本文要介绍的Android系统应用程序框架层的用Java语言来实现的Binder接口了。

       熟悉Android系统的读者,应该能想到应用程序框架中的基于Java语言的Binder接口是通过JNI来调用基于C/C++语言的Binder运行库来为Java应用程序提供进程间通信服务的了。JNI在Android系统中用得相当普遍,SDK中的Java接口API很多只是简单地通过JNI来调用底层的C/C++运行库从而为应用程序服务的。

       这里,我们仍然是通过具体的例子来说明Binder机制在应用程序框架层中的Java接口,主要就是Service Manager、Server和Client这三个角色的实现了。通常,在应用程序中,我们都是把Server实现为Service的形式,并且通过IServiceManager.addService接口来把这个Service添加到Service Manager,Client也是通过IServiceManager.getService接口来获得Service接口,接着就可以使用这个Service提供的功能了,这个与运行时库的Binder接口是一致的。

       前面我们学习Android硬件抽象层时,曾经在应用程序框架层中提供了一个硬件访问服务HelloService,这个Service运行在一个独立的进程中充当Server的角色,使用这个Service的Client运行在另一个进程中,它们之间就是通过Binder机制来通信的了。这里,我们就使用HelloService这个例子来分析Android系统进程间通信Binder机制在应用程序框架层的Java接口源代码。所以希望读者在阅读下面的内容之前,先了解一下前面在Ubuntu上为Android系统的Application Frameworks层增加硬件访问服务这篇文章。

       这篇文章通过五个情景来学习Android系统进程间通信Binder机制在应用程序框架层的Java接口:1. 获取Service Manager的Java远程接口的过程;2. HelloService接口的定义;3. HelloService的启动过程;4. Client获取HelloService的Java远程接口的过程;5.  Client通过HelloService的Java远程接口来使用HelloService提供的服务的过程。

       一.  获取Service Manager的Java远程接口

       我们要获取的Service Manager的Java远程接口是一个ServiceManagerProxy对象的IServiceManager接口。我们现在就来看看ServiceManagerProxy类是长什么样子的:

 

这里可以看出,ServiceManagerProxy类实现了IServiceManager接口,IServiceManager提供了getService和addService两个成员函数来管理系统中的Service。从ServiceManagerProxy类的构造函数可以看出,它需要一个BinderProxy对象的IBinder接口来作为参数。因此,要获取Service Manager的Java远程接口ServiceManagerProxy,首先要有一个BinderProxy对象。下面将会看到这个BinderProxy对象是如何获得的。

         再来看一下是通过什么路径来获取Service Manager的Java远程接口ServiceManagerProxy的。这个主角就是ServiceManager了,我们也先看一下ServiceManager是长什么样子的:

 

 ServiceManager类有一个静态成员函数getIServiceManager,它的作用就是用来获取Service Manager的Java远程接口了,而这个函数又是通过ServiceManagerNative来获取Service Manager的Java远程接口的。

        接下来,我们就看一下ServiceManager.getIServiceManager这个函数的实现,这个函数定义在frameworks/base/core/java/android/os/ServiceManager.java文件中:

 

  1. public final class ServiceManager {  
  2.     ......  
  3.     private static IServiceManager sServiceManager;  
  4.     ......  
  5.     private static IServiceManager getIServiceManager() {  
  6.         if (sServiceManager != null) {  
  7.             return sServiceManager;  
  8.         }  
  9.  
  10.         // Find the service manager  
  11.         sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());  
  12.         return sServiceManager;  
  13.     }  
  14.     ......  

如果其静态成员变量sServiceManager尚未创建,那么就调用ServiceManagerNative.asInterface函数来创建。在调用ServiceManagerNative.asInterface函数之前,首先要通过BinderInternal.getContextObject函数来获得一个BinderProxy对象。

 

        我们来看一下BinderInternal.getContextObject的实现,这个函数定义在frameworks/base/core/java/com/android/internal/os/BinderInternal.java文件中:

 

  1. public class BinderInternal {  
  2.     ......  
  3.     /**  
  4.     * Return the global "context object" of the system.  This is usually  
  5.     * an implementation of IServiceManager, which you can use to find  
  6.     * other services.  
  7.     */  
  8.     public static final native IBinder getContextObject();  
  9.       
  10.     ......  

 这里可以看出,BinderInternal.getContextObject是一个JNI方法,它实现在frameworks/base/core/jni/android_util_Binder.cpp文件中:

 

  1. static jobject android_os_BinderInternal_getContextObject(JNIEnv* env, jobject clazz)  
  2. {  
  3.     sp<IBinder> b = ProcessState::self()->getContextObject(NULL);  
  4.     return javaObjectForIBinder(env, b);  

   这里看到我们熟悉的ProcessState::self()->getContextObject函数,具体可以参考浅谈Android系统进程间通信(IPC)机制Binder中的Server和Client获得Service Manager接口之路一文。ProcessState::self()->getContextObject函数返回一个BpBinder对象,它的句柄值是0,即下面语句:

 

  1. sp<IBinder> b = ProcessState::self()->getContextObject(NULL); 

  相当于是:

 

  1. sp<IBinder> b = new BpBinder(0); 

     接着调用javaObjectForIBinder把这个BpBinder对象转换成一个BinderProxy对象:

 

  1. jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val)  
  2. {  
  3.     if (val == NULLreturn NULL;  
  4.  
  5.     if (val->checkSubclass(&gBinderOffsets)) {  
  6.         // One of our own!  
  7.         jobject object = static_cast<JavaBBinder*>(val.get())->object();  
  8.         //printf("objectForBinder %p: it's our own %p!\n", val.get(), object);  
  9.         return object;  
  10.     }  
  11.  
  12.     // For the rest of the function we will hold this lock, to serialize  
  13.     // looking/creation of Java proxies for native Binder proxies.  
  14.     AutoMutex _l(mProxyLock);  
  15.  
  16.     // Someone else's...  do we know about it?  
  17.     jobject object = (jobject)val->findObject(&gBinderProxyOffsets);  
  18.     if (object != NULL) {  
  19.         jobject res = env->CallObjectMethod(object, gWeakReferenceOffsets.mGet);  
  20.         if (res != NULL) {  
  21.             LOGV("objectForBinder %p: found existing %p!\n", val.get(), res);  
  22.             return res;  
  23.         }  
  24.         LOGV("Proxy object %p of IBinder %p no longer in working set!!!", object, val.get());  
  25.         android_atomic_dec(&gNumProxyRefs);  
  26.         val->detachObject(&gBinderProxyOffsets);  
  27.         env->DeleteGlobalRef(object);  
  28.     }  
  29.  
  30.     object = env->NewObject(gBinderProxyOffsets.mClass, gBinderProxyOffsets.mConstructor);  
  31.     if (object != NULL) {  
  32.         LOGV("objectForBinder %p: created new %p!\n", val.get(), object);  
  33.         // The proxy holds a reference to the native object.  
  34.         env->SetIntField(object, gBinderProxyOffsets.mObject, (int)val.get());  
  35.         val->incStrong(object);  
  36.  
  37.         // The native object needs to hold a weak reference back to the  
  38.         // proxy, so we can retrieve the same proxy if it is still active.  
  39.         jobject refObject = env->NewGlobalRef(  
  40.                 env->GetObjectField(object, gBinderProxyOffsets.mSelf));  
  41.         val->attachObject(&gBinderProxyOffsets, refObject,  
  42.                 jnienv_to_javavm(env), proxy_cleanup);  
  43.  
  44.         // Note that a new object reference has been created.  
  45.         android_atomic_inc(&gNumProxyRefs);  
  46.         incRefsCreated(env);  
  47.     }  
  48.  
  49.     return object;  

     在介绍这个函数之前,先来看两个变量gBinderOffsets和gBinderProxyOffsets的定义。

 

        先看gBinderOffsets的定义:

 

  1. static struct bindernative_offsets_t  
  2. {  
  3.     // Class state.  
  4.     jclass mClass;  
  5.     jmethodID mExecTransact;  
  6.  
  7.     // Object state.  
  8.     jfieldID mObject;  
  9.  
  10. } gBinderOffsets; 

 简单来说,gBinderOffsets变量是用来记录上面第二个类图中的Binder类的相关信息的,它是在注册Binder类的JNI方法的int_register_android_os_Binder函数初始化的:

 

  1. const char* const kBinderPathName = "android/os/Binder";  
  2.  
  3. static int int_register_android_os_Binder(JNIEnv* env)  
  4. {  
  5.     jclass clazz;  
  6.  
  7.     clazz = env->FindClass(kBinderPathName);  
  8.     LOG_FATAL_IF(clazz == NULL"Unable to find class android.os.Binder");  
  9.  
  10.     gBinderOffsets.mClass = (jclass) env->NewGlobalRef(clazz);  
  11.     gBinderOffsets.mExecTransact  
  12.         = env->GetMethodID(clazz, "execTransact""(IIII)Z");  
  13.     assert(gBinderOffsets.mExecTransact);  
  14.  
  15.     gBinderOffsets.mObject  
  16.         = env->GetFieldID(clazz, "mObject""I");  
  17.     assert(gBinderOffsets.mObject);  
  18.  
  19.     return AndroidRuntime::registerNativeMethods(  
  20.         env, kBinderPathName,  
  21.         gBinderMethods, NELEM(gBinderMethods));  

    再来看gBinderProxyOffsets的定义:

 

  1. static struct binderproxy_offsets_t  
  2. {  
  3.     // Class state.  
  4.     jclass mClass;  
  5.     jmethodID mConstructor;  
  6.     jmethodID mSendDeathNotice;  
  7.  
  8.     // Object state.  
  9.     jfieldID mObject;  
  10.     jfieldID mSelf;  
  11.  
  12. } gBinderProxyOffsets; 

简单来说,gBinderProxyOffsets是用来变量是用来记录上面第一个图中的BinderProxy类的相关信息的,它是在注册BinderProxy类的JNI方法的int_register_android_os_BinderProxy函数初始化的:

 

  1. const char* const kBinderProxyPathName = "android/os/BinderProxy";  
  2.  
  3. static int int_register_android_os_BinderProxy(JNIEnv* env)  
  4. {  
  5.     jclass clazz;  
  6.  
  7.     clazz = env->FindClass("java/lang/ref/WeakReference");  
  8.     LOG_FATAL_IF(clazz == NULL"Unable to find class java.lang.ref.WeakReference");  
  9.     gWeakReferenceOffsets.mClass = (jclass) env->NewGlobalRef(clazz);  
  10.     gWeakReferenceOffsets.mGet  
  11.         = env->GetMethodID(clazz, "get""()Ljava/lang/Object;");  
  12.     assert(gWeakReferenceOffsets.mGet);  
  13.  
  14.     clazz = env->FindClass("java/lang/Error");  
  15.     LOG_FATAL_IF(clazz == NULL"Unable to find class java.lang.Error");  
  16.     gErrorOffsets.mClass = (jclass) env->NewGlobalRef(clazz);  
  17.       
  18.     clazz = env->FindClass(kBinderProxyPathName);  
  19.     LOG_FATAL_IF(clazz == NULL"Unable to find class android.os.BinderProxy");  
  20.  
  21.     gBinderProxyOffsets.mClass = (jclass) env->NewGlobalRef(clazz);  
  22.     gBinderProxyOffsets.mConstructor  
  23.         = env->GetMethodID(clazz, "<init>""()V");  
  24.     assert(gBinderProxyOffsets.mConstructor);  
  25.     gBinderProxyOffsets.mSendDeathNotice  
  26.         = env->GetStaticMethodID(clazz, "sendDeathNotice""(Landroid/os/IBinder$DeathRecipient;)V");  
  27.     assert(gBinderProxyOffsets.mSendDeathNotice);  
  28.  
  29.     gBinderProxyOffsets.mObject  
  30.         = env->GetFieldID(clazz, "mObject""I");  
  31.     assert(gBinderProxyOffsets.mObject);  
  32.     gBinderProxyOffsets.mSelf  
  33.         = env->GetFieldID(clazz, "mSelf""Ljava/lang/ref/WeakReference;");  
  34.     assert(gBinderProxyOffsets.mSelf);  
  35.  
  36.     return AndroidRuntime::registerNativeMethods(  
  37.         env, kBinderProxyPathName,  
  38.         gBinderProxyMethods, NELEM(gBinderProxyMethods));  

 回到前面的javaObjectForIBinder函数中,下面这段代码:

 

  1. if (val->checkSubclass(&gBinderOffsets)) {  
  2.     // One of our own!  
  3.     jobject object = static_cast<JavaBBinder*>(val.get())->object();  
  4.     //printf("objectForBinder %p: it's our own %p!\n", val.get(), object);  
  5.     return object;  

前面说过,这里传进来的参数是一个BpBinder的指针,而BpBinder::checkSubclass继承于父类IBinder::checkSubclass,它什么也不做就返回false。

 

        于是函数继续往下执行:

 

  1. jobject object = (jobject)val->findObject(&gBinderProxyOffsets); 

 由于这个BpBinder对象是第一创建,它里面什么对象也没有,因此,这里返回的object为NULL。

 

        于是函数又继续往下执行:

 

  1. object = env->NewObject(gBinderProxyOffsets.mClass, gBinderProxyOffsets.mConstructor); 

 这里,就创建了一个BinderProxy对象了。创建了之后,要把这个BpBinder对象和这个BinderProxy对象关联起来:
 

  1. env->SetIntField(object, gBinderProxyOffsets.mObject, (int)val.get()); 

 就是通过BinderProxy.mObject成员变量来关联的了,BinderProxy.mObject成员变量记录了这个BpBinder对象的地址。

 

        接下去,还要把它放到BpBinder里面去,下次就要使用时,就可以在上一步调用BpBinder::findObj把它找回来了:

 

  1. val->attachObject(&gBinderProxyOffsets, refObject,  
  2.                 jnienv_to_javavm(env), proxy_cleanup); 

   最后,就把这个BinderProxy返回到android_os_BinderInternal_getContextObject函数,最终返回到最开始的ServiceManager.getIServiceManager函数中来了,于是,我们就获得一个BinderProxy对象了。

 

        回到ServiceManager.getIServiceManager中,从下面语句返回:

 

  1. sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject()); 

   相当于是:

 

  1. sServiceManager = ServiceManagerNative.asInterface(new BinderProxy()); 

 接下去就是调用ServiceManagerNative.asInterface函数了,这个函数定义在frameworks/base/core/java/android/os/ServiceManagerNative.java文件中:

 

  1. public abstract class ServiceManagerNative ......  
  2. {  
  3.     ......  
  4.     static public IServiceManager asInterface(IBinder obj)  
  5.     {  
  6.         if (obj == null) {  
  7.             return null;  
  8.         }  
  9.         IServiceManager in =  
  10.             (IServiceManager)obj.queryLocalInterface(descriptor);  
  11.         if (in != null) {  
  12.             return in;  
  13.         }  
  14.  
  15.         return new ServiceManagerProxy(obj);  
  16.     }  
  17.     ......  

  这里的参数obj是一个BinderProxy对象,它的queryLocalInterface函数返回null。因此,最终以这个BinderProxy对象为参数创建一个ServiceManagerProxy对象。

 

       返回到ServiceManager.getIServiceManager中,从下面语句返回:

 

  1. sServiceManager = ServiceManagerNative.asInterface(new BinderProxy()); 

    就相当于是:

 

  1. sServiceManager = new ServiceManagerProxy(new BinderProxy()); 

 于是,我们的目标终于完成了。

 

      总结一下,就是在Java层,我们拥有了一个Service Manager远程接口ServiceManagerProxy,而这个ServiceManagerProxy对象在JNI层有一个句柄值为0的BpBinder对象与之通过gBinderProxyOffsets关联起来。

      这样获取Service Manager的Java远程接口的过程就完成了。

      二. HelloService接口的定义

      前面我们在学习Android系统的硬件抽象层(HAL)时,在在Ubuntu上为Android系统的Application Frameworks层增加硬件访问服务这篇文章中,我们编写了一个硬件服务HelloService,它的服务接口定义在frameworks/base/core/java/android/os/IHelloService.aidl文件中:

 

  1. package android.os;  
  2.  
  3. interface IHelloService  
  4. {  
  5.     void setVal(int val);  
  6.     int getVal();  

这个服务接口很简单,只有两个函数,分别用来读写硬件寄存器。

       注意,这是一个aidl文件,编译后会生成一个IHelloService.java。我们来看一下这个文件的内容隐藏着什么奥秘,可以这么神奇地支持进程间通信。

 

  1. /*  
  2.  * This file is auto-generated.  DO NOT MODIFY.  
  3.  * Original file: frameworks/base/core/java/android/os/IHelloService.aidl  
  4.  */  
  5. package android.os;  
  6. public interface IHelloService extends android.os.IInterface  
  7. {  
  8.     /** Local-side IPC implementation stub class. */  
  9.     public static abstract class Stub extends android.os.Binder implements android.os.IHelloService  
  10.     {  
  11.         private static final java.lang.String DESCRIPTOR = "android.os.IHelloService";  
  12.         /** Construct the stub at attach it to the interface. */  
  13.         public Stub()  
  14.         {  
  15.             this.attachInterface(this, DESCRIPTOR);  
  16.         }  
  17.  
  18.         /**  
  19.         * Cast an IBinder object into an android.os.IHelloService interface,  
  20.         * generating a proxy if needed.  
  21.         */  
  22.         public static android.os.IHelloService asInterface(android.os.IBinder obj)  
  23.         {  
  24.             if ((obj==null)) {  
  25.                 return null;  
  26.             }  
  27.             android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);  
  28.             if (((iin!=null)&&(iin instanceof android.os.IHelloService))) {  
  29.                 return ((android.os.IHelloService)iin);  
  30.             }  
  31.             return new android.os.IHelloService.Stub.Proxy(obj);  
  32.         }  
  33.  
  34.         public android.os.IBinder asBinder()  
  35.         {  
  36.             return this;  
  37.         }  
  38.  
  39.         @Override   
  40.         public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
  41.         {  
  42.             switch (code)  
  43.             {  
  44.                 case INTERFACE_TRANSACTION:  
  45.                 {  
  46.                     reply.writeString(DESCRIPTOR);  
  47.                     return true;  
  48.                 }  
  49.                 case TRANSACTION_setVal:  
  50.                 {  
  51.                     data.enforceInterface(DESCRIPTOR);  
  52.                     int _arg0;  
  53.                     _arg0 = data.readInt();  
  54.                     this.setVal(_arg0);  
  55.                     reply.writeNoException();  
  56.                     return true;  
  57.                 }  
  58.                 case TRANSACTION_getVal:  
  59.                 {  
  60.                     data.enforceInterface(DESCRIPTOR);  
  61.                     int _result = this.getVal();  
  62.                     reply.writeNoException();  
  63.                     reply.writeInt(_result);  
  64.                     return true;  
  65.                 }  
  66.             }  
  67.             return super.onTransact(code, data, reply, flags);  
  68.         }  
  69.  
  70.         private static class Proxy implements android.os.IHelloService  
  71.         {  
  72.             private android.os.IBinder mRemote;  
  73.  
  74.             Proxy(android.os.IBinder remote)  
  75.             {  
  76.                 mRemote = remote;  
  77.             }  
  78.  
  79.             public android.os.IBinder asBinder()  
  80.             {  
  81.                 return mRemote;  
  82.             }  
  83.  
  84.             public java.lang.String getInterfaceDescriptor()  
  85.             {  
  86.                 return DESCRIPTOR;  
  87.             }  
  88.  
  89.             public void setVal(int val) throws android.os.RemoteException  
  90.             {  
  91.                 android.os.Parcel _data = android.os.Parcel.obtain();  
  92.                 android.os.Parcel _reply = android.os.Parcel.obtain();  
  93.                 try {  
  94.                     _data.writeInterfaceToken(DESCRIPTOR);  
  95.                     _data.writeInt(val);  
  96.                     mRemote.transact(Stub.TRANSACTION_setVal, _data, _reply, 0);  
  97.                     _reply.readException();  
  98.                 }  
  99.                 finally {  
  100.                     _reply.recycle();  
  101.                     _data.recycle();  
  102.                 }  
  103.             }  
  104.  
  105.             public int getVal() throws android.os.RemoteException  
  106.             {  
  107.                 android.os.Parcel _data = android.os.Parcel.obtain();  
  108.                 android.os.Parcel _reply = android.os.Parcel.obtain();  
  109.                 int _result;  
  110.                 try {  
  111.                     _data.writeInterfaceToken(DESCRIPTOR);  
  112.                     mRemote.transact(Stub.TRANSACTION_getVal, _data, _reply, 0);  
  113.                     _reply.readException();  
  114.                     _result = _reply.readInt();  
  115.                 }  
  116.                 finally {  
  117.                     _reply.recycle();  
  118.                     _data.recycle();  
  119.                 }  
  120.                 return _result;  
  121.             }  
  122.         }  
  123.  
  124.         static final int TRANSACTION_setVal = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);  
  125.         static final int TRANSACTION_getVal = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);  
  126.     }  
  127.  
  128.     public void setVal(int val) throws android.os.RemoteException;  
  129.     public int getVal() throws android.os.RemoteException;