在前面几篇文章中，我们详细介绍了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文件中：
publicfinal class ServiceManager {
......
privatestaticIServiceManager sServiceManager;
......
privatestaticIServiceManager getIServiceManager() {
if (sServiceManager !=null) {
returnsServiceManager;
}
// Find the service manager
sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());
returnsServiceManager;
}
......
}
如果其静态成员变量sServiceManager尚未创建，那么就调用ServiceManagerNative.asInterface函数来创建。在调用ServiceManagerNative.asInterface函数之前，首先要通过BinderInternal.getContextObject函数来获得一个BinderProxy对象。
我们来看一下BinderInternal.getContextObject的实现，这个函数定义在frameworks/base/core/java/com/android/internal/os/BinderInternal.java文件中：
publicclass BinderInternal {
......
/**
*Returntheglobal"context object"ofthe system. Thisisusually
* an implementationofIServiceManager, which you can usetofind
* other services.
*/
publicstaticfinal native IBinder getContextObject();
......
}
这里可以看出，BinderInternal.getContextObject是一个JNI方法，它实现在frameworks/base/core/jni/android_util_Binder.cpp文件中：
staticjobject android_os_BinderInternal_getContextObject(JNIEnv* env, jobject clazz)
{
sp b = ProcessState::self()->getContextObject(NULL);
returnjavaObjectForIBinder(env, b);
}
这里看到我们熟悉的ProcessState::self()->getContextObject函数，具体可以参考浅谈Android系统进程间通信(IPC)机制Binder中的Server和Client获得Service Manager接口之路一文。ProcessState::self()->getContextObject函数返回一个BpBinder对象，它的句柄值是0，即下面语句：
sp b = ProcessState::self()->getContextObject(NULL);
相当于是：
sp b = new BpBinder(0);
接着调用javaObjectForIBinder把这个BpBinder对象转换成一个BinderProxy对象：
jobject javaObjectForIBinder(JNIEnv* env, const sp& val)
{
if (val ==NULL)returnNULL;
if (val->checkSubclass(&gBinderOffsets)) {
// Oneofour own!
jobject object = static_cast(val.get())->object();
//printf("objectForBinder %p: it's our own %p!\n", val.get(), object);
returnobject;
}
//Forthe restofthefunctionwe will hold this lock,toserialize
// looking/creationofJava proxiesfornative Binder proxies.
AutoMutex _l(mProxyLock);
// Someoneelse's... do we know about it?
jobject object = (jobject)val->findObject(&gBinderProxyOffsets);
if (object !=NULL) {
jobject res = env->CallObjectMethod(object, gWeakReferenceOffsets.mGet);
if (res !=NULL) {
LOGV("objectForBinder %p: found existing %p!\n", val.get(), res);
returnres;
}
LOGV("Proxy object %p of IBinder %p no longer in working set!!!", object, val.get());
android_atomic_dec(&gNumProxyRefs);
val->detachObject(&gBinderProxyOffsets);
env->DeleteGlobalRef(object);
}
object = env->NewObject(gBinderProxyOffsets.mClass, gBinderProxyOffsets.mConstructor);
if (object !=NULL) {
LOGV("objectForBinder %p: created new %p!\n", val.get(), object);
// The proxy holds a referencetothe native object.
env->SetIntField(object, gBinderProxyOffsets.mObject, (int)val.get());
val->incStrong(object);
// The native object needstohold a weak reference backtothe
// proxy, so we can retrieve the same proxy if itisstill active.
jobject refObject = env->NewGlobalRef(
env->GetObjectField(object, gBinderProxyOffsets.mSelf));
val->attachObject(&gBinderProxyOffsets, refObject,
jnienv_to_javavm(env), proxy_cleanup);
// Note that a new object reference has been created.
android_atomic_inc(&gNumProxyRefs);
incRefsCreated(env);
}
returnobject;
}
在介绍这个函数之前，先来看两个变量gBinderOffsets和gBinderProxyOffsets的定义。
先看gBinderOffsets的定义：
staticstruct bindernative_offsets_t
{
// Class state.
jclass mClass;
jmethodID mExecTransact;
// Object state.
jfieldID mObject;
} gBinderOffsets;
简单来说，gBinderOffsets变量是用来记录上面第二个类图中的Binder类的相关信息的，它是在注册Binder类的JNI方法的int_register_android_os_Binder函数初始化的：
constchar* const kBinderPathName ="android/os/Binder";
staticintint_register_android_os_Binder(JNIEnv* env)
{
jclass clazz;
clazz = env->FindClass(kBinderPathName);
LOG_FATAL_IF(clazz ==NULL,"Unable to find class android.os.Binder");
gBinderOffsets.mClass = (jclass) env->NewGlobalRef(clazz);
gBinderOffsets.mExecTransact
= env->GetMethodID(clazz,"execTransact","(IIII)Z");
assert(gBinderOffsets.mExecTransact);
gBinderOffsets.mObject
= env->GetFieldID(clazz,"mObject","I");
assert(gBinderOffsets.mObject);
returnAndroidRuntime::registerNativeMethods(
env, kBinderPathName,
gBinderMethods, NELEM(gBinderMethods));
}
再来看gBinderProxyOffsets的定义：
staticstruct binderproxy_offsets_t
{
// Class state.
jclass mClass;
jmethodID mConstructor;
jmethodID mSendDeathNotice;
// Object state.
jfieldID mObject;
jfieldID mSelf;
} gBinderProxyOffsets;
简单来说，gBinderProxyOffsets是用来变量是用来记录上面第一个图中的BinderProxy类的相关信息的，它是在注册BinderProxy类的JNI方法的int_register_android_os_BinderProxy函数初始化的：
constchar* const kBinderProxyPathName ="android/os/BinderProxy";
staticintint_register_android_os_BinderProxy(JNIEnv* env)
{
jclass clazz;
clazz = env->FindClass("java/lang/ref/WeakReference");
LOG_FATAL_IF(clazz ==NULL,"Unable to find class java.lang.ref.WeakReference");
gWeakReferenceOffsets.mClass = (jclass) env->NewGlobalRef(clazz);
gWeakReferenceOffsets.mGet
= env->GetMethodID(clazz,"get","()Ljava/lang/Object;");
assert(gWeakReferenceOffsets.mGet);
clazz = env->FindClass("java/lang/Error");
LOG_FATAL_IF(clazz ==NULL,"Unable to find class java.lang.Error");
gErrorOffsets.mClass = (jclass) env->NewGlobalRef(clazz);
clazz = env->FindClass(kBinderProxyPathName);
LOG_FATAL_IF(clazz ==NULL,"Unable to find class android.os.BinderProxy");
gBinderProxyOffsets.mClass = (jclass) env->NewGlobalRef(clazz);
gBinderProxyOffsets.mConstructor
= env->GetMethodID(clazz,"","()V");
assert(gBinderProxyOffsets.mConstructor);
gBinderProxyOffsets.mSendDeathNotice
= env->GetStaticMethodID(clazz,"sendDeathNotice","(Landroid/os/IBinder$DeathRecipient;)V");
assert(gBinderProxyOffsets.mSendDeathNotice);
gBinderProxyOffsets.mObject
= env->GetFieldID(clazz,"mObject","I");
assert(gBinderProxyOffsets.mObject);
gBinderProxyOffsets.mSelf
= env->GetFieldID(clazz,"mSelf","Ljava/lang/ref/WeakReference;");
assert(gBinderProxyOffsets.mSelf);
returnAndroidRuntime::registerNativeMethods(
env, kBinderProxyPathName,
gBinderProxyMethods, NELEM(gBinderProxyMethods));
}
回到前面的javaObjectForIBinder函数中，下面这段代码：
if (val->checkSubclass(&gBinderOffsets)) {
// Oneofour own!
jobject object = static_cast(val.get())->object();
//printf("objectForBinder %p: it's our own %p!\n", val.get(), object);
returnobject;
}
前面说过，这里传进来的参数是一个BpBinder的指针，而BpBinder::checkSubclass继承于父类IBinder::checkSubclass，它什么也不做就返回false。
于是函数继续往下执行：
jobject object = (jobject)val->findObject(&gBinderProxyOffsets);
由于这个BpBinder对象是第一创建，它里面什么对象也没有，因此，这里返回的object为NULL。
于是函数又继续往下执行：
object = env->NewObject(gBinderProxyOffsets.mClass, gBinderProxyOffsets.mConstructor);
这里，就创建了一个BinderProxy对象了。创建了之后，要把这个BpBinder对象和这个BinderProxy对象关联起来：
env->SetIntField(object, gBinderProxyOffsets.mObject, (int)val.get());
就是通过BinderProxy.mObject成员变量来关联的了，BinderProxy.mObject成员变量记录了这个BpBinder对象的地址。
接下去，还要把它放到BpBinder里面去，下次就要使用时，就可以在上一步调用BpBinder::findObj把它找回来了：
val->attachObject(&gBinderProxyOffsets, refObject,
jnienv_to_javavm(env), proxy_cleanup);
最后，就把这个BinderProxy返回到android_os_BinderInternal_getContextObject函数，最终返回到最开始的ServiceManager.getIServiceManager函数中来了，于是，我们就获得一个BinderProxy对象了。
回到ServiceManager.getIServiceManager中，从下面语句返回：
sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());
相当于是：
sServiceManager = ServiceManagerNative.asInterface(new BinderProxy());
接下去就是调用ServiceManagerNative.asInterface函数了，这个函数定义在frameworks/base/core/java/android/os/ServiceManagerNative.java文件中：
publicabstract class ServiceManagerNative ......
{
......
staticpublicIServiceManager asInterface(IBinder obj)
{
if (obj ==null) {
returnnull;
}
IServiceManagerin=
(IServiceManager)obj.queryLocalInterface(descriptor);
if (in!=null) {
returnin;
}
returnnew ServiceManagerProxy(obj);
}
......
}
这里的参数obj是一个BinderProxy对象，它的queryLocalInterface函数返回null。因此，最终以这个BinderProxy对象为参数创建一个ServiceManagerProxy对象。
返回到ServiceManager.getIServiceManager中，从下面语句返回：
sServiceManager = ServiceManagerNative.asInterface(new BinderProxy());
就相当于是：
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文件中：
package android.os;
interface IHelloService
{
void setVal(intval);
intgetVal();
}
这个服务接口很简单，只有两个函数，分别用来读写硬件寄存器。
注意，这是一个aidl文件，编译后会生成一个IHelloService.java。我们来看一下这个文件的内容隐藏着什么奥秘，可以这么神奇地支持进程间通信。
/*
* This fileisauto-generated. DONOTMODIFY.
* Original file: frameworks/base/core/java/android/os/IHelloService.aidl
*/
package android.os;
publicinterface IHelloService extends android.os.IInterface
{
/**Local-side IPC implementation stub class. */
publicstaticabstract class Stub extends android.os.Binder implements android.os.IHelloService
{
privatestaticfinal java.lang.String DESCRIPTOR ="android.os.IHelloService";
/** Construct the stubatattach ittothe interface. */
publicStub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
*Castan IBinder objectintoan android.os.IHelloService interface,
* generating a proxy if needed.
*/
publicstaticandroid.os.IHelloService asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
returnnull;
}
android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof android.os.IHelloService))) {
return((android.os.IHelloService)iin);
}
returnnew android.os.IHelloService.Stub.Proxy(obj);
}
publicandroid.os.IBinder asBinder()
{
returnthis;
}
@Override
publicboolean onTransact(intcode, android.os.Parcel data, android.os.Parcel reply,intflags) throws android.os.RemoteException
{
switch (code)
{
caseINTERFACE_TRANSACTION:
{
reply.writeString(DESCRIPTOR);
returntrue;
}
caseTRANSACTION_setVal:
{
data.enforceInterface(DESCRIPTOR);
int_arg0;
_arg0 = data.readInt();
this.setVal(_arg0);
reply.writeNoException();
returntrue;
}
caseTRANSACTION_getVal:
{
data.enforceInterface(DESCRIPTOR);
int_result = this.getVal();
reply.writeNoException();
reply.writeInt(_result);
returntrue;
}
}
returnsuper.onTransact(code, data, reply, flags);
}
privatestaticclass Proxy implements android.os.IHelloService
{
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote)
{
mRemote = remote;
}
publicandroid.os.IBinder asBinder()
{
returnmRemote;
}
publicjava.lang.String getInterfaceDescriptor()
{
returnDESCRIPTOR;
}
publicvoid setVal(intval) 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(val);
mRemote.transact(Stub.TRANSACTION_setVal, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
publicintgetVal() 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);
mRemote.transact(Stub.TRANSACTION_getVal, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
}
finally {
_reply.recycle();
_data.recycle();
}
return_result;
}
}
staticfinalintTRANSACTION_setVal = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
staticfinalintTRANSACTION_getVal = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}
publicvoid setVal(intval) throws android.os.RemoteException;
publicintgetVal() throws android.os.RemoteException;
}
扫一扫
105
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
