Binder in Java

Android在Native层实现了进程间的Binder通信,但是上层应用程序的开发及Framework的实现都是Java,用Java层再实现一次肯定是不合理的,Java可以通过JNI调用Native Code,所以通过JNI复用Binder在Native层的实现就是一个顺理成章的事情。

注册Service

在Init进程的init2阶段,系统启动了ServerThread,在ServerThread中会启动很多用Java实现的系统服务,比如说PowerService:

power = new PowerManagerService();
ServiceManager.addService(Context.POWER_SERVICE, power);

新建Server端实体,然后向ServiceManager注册,从代码表面看是和Native层Binder一样的。PowerManagerService继承自Java层的Binder类:

public final class PowerManagerService extends IPowerManager.Stub
public interface IPowerManager extends android.os.IInterface {
    public static abstract class Stub extends android.os.Binder implements android.os.IPowerManager {

所以在new PowerManagerService时会调用Binder的构造函数,Binder的构造函数中调用了init(),init是native方法,执行JNI的android_os_Binder_init:

static void android_os_Binder_init(JNIEnv* env, jobject obj)
{
    JavaBBinderHolder* jbh = new JavaBBinderHolder();
    if (jbh == NULL) {
        jniThrowException(env, "java/lang/OutOfMemoryError", NULL);
        return;
    }
    ALOGV("Java Binder %p: acquiring first ref on holder %p", obj, jbh);
    jbh->incStrong((void*)android_os_Binder_init);
    env->SetIntField(obj, gBinderOffsets.mObject, (int)jbh);
}

在android_os_Binder_init,新建了一个JavaBBinderHolder对角,并将其指针保存在了obj即Binder的gBinderOffsets.mObject域中,而gBinderOffsets.mObject又是个什么东西?看一下它的定义:

static struct bindernative_offsets_t
{
    jclass mClass;
    jmethodID mExecTransact;
    jfieldID mObject;
} gBinderOffsets;

在AndroidRuntine::startReg中会调用register_android_os_Binder,register_android_os_Binder会调用int_register_android_os_Binder等函数建立Java层Binder、BinderProxy、BinderInternal、Log等与Native层的映射关系。比如在int_register_android_os_Binder中会通过JNI标准的方法GetMethodID等初始化gBinderOffsets:

static int int_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);

    return AndroidRuntime::registerNativeMethods(
        env, kBinderPathName,
        gBinderMethods, NELEM(gBinderMethods));
}

在android_os_Binder_init中new了一个JavaBBinderHolder,JavaBBinderHolder new了一个JavaBBinder保存到了自己的成员wp<JavaBBinder> mBinder中。

JavaBBinder继承自Native层的BBinder,并且将Java层的Binder对象(此处即PowerManagerService)保存到了成员mObject中,并通过object()方法返回。

现在我们发现,JavaBinder,BinderBBinderHolder,JavaBBinder存在相互引用关系:

  • PowerManagerService.mObject->JavaBBinderHolder
  • JavaBBinderHolder.mBinder->JavaBBinder
  • JavaBBinder.mObject->PowerManagerService

Binder是一种Client-Server类型的IPC,PowerManagerService属于Server端,从Native Binder中我们知道,Client通过BpBinder经由Binder Driver、BBinder与Serverr通信,PowerManagerService通过JavaBBinderHolder引用JavaBBinder,而JavaBBinder继承自BBinder,符合了Server的条件,Server实体有了,接下来就要向ServiceManager注册,通过以下方法:

ServiceManager.addService(Context.POWER_SERVICE,power);
// In ServiceManager public static void addService(String name, IBinder service) { try { getIServiceManager().addService(name, service, false); } catch (RemoteException e) { Log.e(TAG, "error in addService", e); } } private static IServiceManager getIServiceManager() { if (sServiceManager != null) { return sServiceManager; } sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject()); return sServiceManager; }

 BinderInternal.getContextObject是一个Native方法,调用JNIandroid_os_BinderInternal_getContextObject:

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

ProcessState::self()->getContextObject就很熟悉了,在Binder in Native中可以知道,这个调用返回new BpBinder(0)。

javaObjectForIBinder的作用就是,新建一个Java层的BinderProxy对象,将Native层的BpBinder保存到BinderProxy.mObject,并将BinderProxy的弱引用通过attachObject保存到Native层的BpBinder(成员mObjects中),这样Java层的BinderProxy与Native层的BpBinder就可以相互引用了。Java层的BinderProxy及其在Native层的表示间的映射关系同Binder类一样也是在register_android_os_Binder中建立的。

上面红色的部分就等效于:

gServiceManager = ServiceManagerNative.asInterface(new BinderProxy());

 ServiceManagerNative继承自IServiceManager与Java层的Binder类,BinderProxy可以引用BpBinder。asInterface就像Native Binder中的interface_cast的,asInterface实现可以简化为:

return new ServiceManagerProxy(obj);

obj是BinderProxy对象。ServiceManagerProxy直接将这个BinderProxy对象保存在了成员mRemote中,并通过asBinder返回。

ServiceManagerProxy同时实现了IServiceManager,而且由其名字可知,ServiceManagerProxy是作为ServiceManager在Client端的代理的,看下它的addService的实现:

public void addService(String name, IBinder service, boolean allowIsolated)
            throws RemoteException {
        Parcel data = Parcel.obtain();
        Parcel reply = Parcel.obtain();
        data.writeInterfaceToken(IServiceManager.descriptor);
        data.writeString(name);
        data.writeStrongBinder(service);
        data.writeInt(allowIsolated ? 1 : 0);
        mRemote.transact(ADD_SERVICE_TRANSACTION, data, reply, 0);
        reply.recycle();
        data.recycle();
    }

writeStrongBinder是Native方法,调用android_os_Parcel_writeStrongBinder,在android_os_Parcel_writeStrongBinder将Java Parcel转换成Native Parcel(Native Parcel的指针保存在Java Parcel的成员变量中),然后调用以下语句:

const status_t err = parcel->writeStrongBinder(ibinderForJavaObject(env, object));

sp<IBinder> ibinderForJavaObject(JNIEnv* env, jobject obj)根据obj返回JavaBBinder或Native BpBinder,在这里传入的obj 是PowerManagerService,返回JavaBBinder。接下来调用了mRemote.transact,mRemote是BinderProxy的对象。

BinderProxy的transact是Native方法,调用JNIandroid_os_BinderProxy_transact,在android_os_BinderProxy_transact中通过:

IBinder* target = (IBinder*) env->GetIntField(obj, gBinderProxyOffsets.mObject);
...
status_t err = target->transact(code, *data, reply, flags);

获取到BinderProxy中保存的BpBinder,然后调用BpBinder的transact,到这里就和Native Binder的调用流程一样了,Native ServiceManager会注册我们的Service,在这里是PowerManagerService。

 获得注册的Service

Service已经向ServiceManager注册了,那么我们怎么获得所注册的Service,或者更准确地说,怎么获得所注册的Service的代理呢?

回想下我们在APK中是怎么获取系统服务的:

PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);

看一下getSystemService的实现,位于ContextImpl中:

    @Override
    public Object getSystemService(String name) {
        ServiceFetcher fetcher = SYSTEM_SERVICE_MAP.get(name);
        return fetcher == null ? null : fetcher.getService(this);
    }

        registerService(POWER_SERVICE, new ServiceFetcher() {
                public Object createService(ContextImpl ctx) {
                    IBinder b = ServiceManager.getService(POWER_SERVICE);
                    IPowerManager service = IPowerManager.Stub.asInterface(b);
                    return new PowerManager(ctx.getOuterContext(),
                            service, ctx.mMainThread.getHandler());
                }});

1. ServiceManager.getService获得IBinder对象

同ServiceManager.addService一样,ServiceManager.getService首先获得一个ServiceManagerProxy的对象,然后调用它的getService方法:

    public IBinder getService(String name) throws RemoteException {
        ...
        mRemote.transact(GET_SERVICE_TRANSACTION, data, reply, 0);
        IBinder binder = reply.readStrongBinder();
        ...
        return binder;
    }

mRemote是BinderProxy对象,内部引用了BpBinder,调用BinderProxy的Native方法transact与Binder通信,然后通过readStrongBinder()读取返回的数据,一个IBinder对象。

readStrongBinder中通过javaObjectForIBinder返回了BinderProxy对象,前面已经说过。

2. 通过asInterface将获得的IBinder对象转换成IPowerManager对象

IPowerManager.Stub.asInterface可以简化为:

return new android.os.IPowerManager.Stub.Proxy(obj);

Proxy只是将传入的参数(BinderProxy)保存到了成员mRemote中并通过asBinder返回。

Proxy与Stub都是IPowerManager.aidl编译后生成的类,都位于IPowerManager.java中。关于aidl网上有很多资料。

3. IPowerManager对象是不向外暴露的,构造一个PowerManager封装IPowerManager返回。

PowerManager只是将IPowerManager保存在了成员变量中,PowerManager中保存了BinderProxy,BinderProxy中引用了Native BpBinder,就可以与Server进行通信了。

Server端响应Client请求

Server端接收到Client的请求后会调用BBinder的transact处理请求,transact会调用虚函数onTransact,JavaBBinder继承自BBinder,所以会调用JavaBBinder::onTransact,在JavaBBinder::onTransact中有以下一句:

jboolean res = env->CallBooleanMethod(mObject, gBinderOffsets.mExecTransact, code, (int32_t)&data, (int32_t)reply, flags);

通过JNI反向调用了Java类的方法。前面我们知道了,Java实现的Service中,Service对象,JavaBBinderHolder,JavaBBinder存在相互引用关系,JavaBBinder的成员mObject引用了Java中的Service对象,比如此处的PowerManagerService,而且在int_register_android_os_Binder中通过

gBinderOffsets.mExecTransact  = env->GetMethodID(clazz, "execTransact", "(IIII)Z");

将Service的execTransact方法(其实是Binder的方法)保存在了gBinderOffsets.mExecTransact中,所在以JavaBBinder::onTransact中会调用Binder.execTransact。在Binder.execTransact中调用了onTransact,执行子类即Stub类的onTransact方法,在onTransact中根据code值执行相应的方法,最终是调用Service类(继承自Stub)中相应的方法。

总结

Java层通过JNI利用了Native层的Binder,在JNI函数注册时会建立Java层Binder,BinderProxy,BinderInternal等类与Native层的映射关系。Java层Service实体继承自Java层的Binder类,在Binder类初始化时会创建一个JavaBBinderHolder作为JavaBBinder的容器,JavaBBinder继承自BBinder,Java层Binder类引用JavaBBinderHolder,JavaBBinderHolder引用JavaBBinder,JavaBBinder继承自BBinder并引用Java层的Binder类,这三者互相引用,这样Java层的Service实体就可以通过BBinder与驱动进行通信了。

进程向Java层的ServiceManager代理发送GET_SERVICE请求,然后通过JNI向Native层的ServiceManager请求服务,Native层的ServiceManager返回请求的服务的代理对象BpBinder,通过javaObjectForIBinder函数将Native的BpBinder转化为Java层对应的BinderProxy,然后通过aidl生成的Stub类asInterface方法将BinderProxy封闭到请求的服务的代理对象中,这个代理对象引用了BinderProxy,BinderProxy内部保存了Native层的BpBinder,这样就可以与驱动进行通信了。

当Server端接收到Client的请求时会通过BBinder的transact调用Server的服务,BBinder的transact调用虚函数onTransact,这样就会调到BBinder的子类JavaBBinder的onTransact,而JavaBinder::onTransact会通过JNI反向调用到Java层Binder类的execTransact,Binder.execTransact调用onTransact即子类Stub的onTransact,然后根据code值调用Service实体类(继承自Stub)相应的方法。

posted @ 2013-09-23 14:52  AngelDevil  阅读(...)  评论(... 编辑 收藏