Android Binder分析四：Java service的注册

这一章通过WifiService来分析一下在Java framework中如何注册Service，在分析注册WifiService之前，先来看一下WifiService相关的类

下面是我们以前分析过的WifiService的注册代码：

               try {                    Slog.i(TAG, "Wi-Fi Service");                    wifi = new WifiService(context);                    ServiceManager.addService(Context.WIFI_SERVICE, wifi);                } catch (Throwable e) {                    reportWtf("starting Wi-Fi Service", e);                }

这里首先构造一个WifiService对象，在构造WifiService对象时，我们前面已经看过的构造函数了，这里主要来看一下它的两个父类的构造函数：

        public Stub() {            this.attachInterface(this, DESCRIPTOR);        }    public void attachInterface(IInterface owner, String descriptor) {        mOwner = owner;        mDescriptor = descriptor;    }

IWifiManager.Stub的构造函数中调用attachInterface将一个interface与binder联系起来，方便后面查找。

    public Binder() {        init();    }

Binder的构造函数主要就是调用init去做初始化的工作，init的实现在android_util_Binder.cpp中，我们后面再来分析。

这里调用ServiceManager的addService方法，第一个参数Context.WIFI_SERVICE是"wifi"字串；第二个参数是WifiService对象，WifiService是继承于Binder的。来看addService方法：

    public static void addService(String name, IBinder service) {        try {            getIServiceManager().addService(name, service, false);        } catch (RemoteException e) {            Log.e(TAG, "error in addService", e);        }    }

首先调用getIServiceManager来获取一个ServiceManagerProxy对象，如下：

    private static IServiceManager getIServiceManager() {        if (sServiceManager != null) {            return sServiceManager;        }        // Find the service manager        sServiceManager = ServiceManagerNative.asInterface(BinderInternal.getContextObject());        return sServiceManager;    }

下面先来看一下Java层的ServiceManager相关的文件结构：

在分析BinderInternal.getContextObject()前，我们先来分析一下android_util_Binder.cpp这个文件，它是Java层的binder和Native层的binder中间的桥梁。android_util_Binder.cpp的初始化函数是register_android_os_Binder，它在AndroidRuntime初始化时被加载执行。在register_android_os_Binder方法中，又分为三个步骤，第一步映射Java层的Binder类，并注册其中的Native函数；第二步映射Java层的BinderInternal类，并注册其中的Native函数；第三步映射Java层的BinderProxy类，并注册其中的Native函数：

int register_android_os_Binder(JNIEnv* env){    if (int_register_android_os_Binder(env) < 0)        return -1;    if (int_register_android_os_BinderInternal(env) < 0)        return -1;    if (int_register_android_os_BinderProxy(env) < 0)        return -1;    jclass clazz;    clazz = env->FindClass("android/util/Log");    LOG_FATAL_IF(clazz == NULL, "Unable to find class android.util.Log");    gLogOffsets.mClass = (jclass) env->NewGlobalRef(clazz);    gLogOffsets.mLogE = env->GetStaticMethodID(        clazz, "e", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Throwable;)I");    assert(gLogOffsets.mLogE);    clazz = env->FindClass("android/os/ParcelFileDescriptor");    LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.ParcelFileDescriptor");    gParcelFileDescriptorOffsets.mClass = (jclass) env->NewGlobalRef(clazz);    gParcelFileDescriptorOffsets.mConstructor        = env->GetMethodID(clazz, "<init>", "(Ljava/io/FileDescriptor;)V");    clazz = env->FindClass("android/os/StrictMode");    LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.StrictMode");    gStrictModeCallbackOffsets.mClass = (jclass) env->NewGlobalRef(clazz);    gStrictModeCallbackOffsets.mCallback = env->GetStaticMethodID(        clazz, "onBinderStrictModePolicyChange", "(I)V");    LOG_FATAL_IF(gStrictModeCallbackOffsets.mCallback == NULL,                 "Unable to find strict mode callback.");    return 0;}

首先来看int_register_android_os_Binder方法：

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));}

首先通过JNI的FindClass把Binder.class加载进来，然后在gBinderOffsets保存Binder.class的引用和Binder的execTransact函数ID，通过mObject保存Binder中mObject变量的ID，这个变量用于以后存储JNI层JavaBBinderHolder的地址。最后调用registerNativeMethods将Java层的函数和Native层的函数建立好映射关系。int_register_android_os_BinderInternal和int_register_android_os_BinderProxy与int_register_android_os_Binder实现差不多，通过上面三个函数，我们可以在JNI层看到下面的数据关系：

结构体变量名解释gBinderOffsetsmClass保存Binder.class的ref mExecTransact保存Binder.class的execTransact函数ID mObject保存Binder.class的mObject成员ID，实际保存JavaBBinderHolder的地址gBinderInternalOffsetsmClass保存BinderInternal.class的ref mForceGc保存BinderInternal.class的forceBinderGc函数IDgBinderProxyOffsetsmClass保存BinderProxy.class的ref mConstructor保存BinderProxy.class的init函数ID mSendDeathNotice保存BinderProxy.class的sendDeathNotice函数ID mObject保存BinderProxy.class的mObject成员ID，实际保存BpBinder地址 mSelf保存BinderProxy.class的mSelf成员ID，用于注册将BpBinder和BinderProxy绑定 mOrgue保存BinderProxy.class的mOrgue成员ID，实际保存DeathRecipientList地址

在register_android_os_Binder函数的后面，主要是保存Log、ParcelFileDescriptor和StrictMode工具类的一些函数和变量地址。回到getIServiceManager()方法中，BinderInternal.getContextObject()这个函数，它透过JNI调用，实现在android_util_Binder.cpp中的

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

ProcessState::self()->getContextObject(NULL)我们前面分析过，它就是返回BpBinder(0)，来看javaObjectForIBinder方法：

jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val){    if (val == NULL) return NULL;    if (val->checkSubclass(&gBinderOffsets)) {        return object;    }    AutoMutex _l(mProxyLock);    jobject object = (jobject)val->findObject(&gBinderProxyOffsets);    if (object != NULL) {        jobject res = jniGetReferent(env, object);        if (res != NULL) {            ALOGV("objectForBinder %p: found existing %p!\n", val.get(), res);            return res;        }        LOGDEATH("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) {        env->SetIntField(object, gBinderProxyOffsets.mObject, (int)val.get());        val->incStrong((void*)javaObjectForIBinder);        jobject refObject = env->NewGlobalRef(                env->GetObjectField(object, gBinderProxyOffsets.mSelf));        val->attachObject(&gBinderProxyOffsets, refObject,                jnienv_to_javavm(env), proxy_cleanup);        sp<DeathRecipientList> drl = new DeathRecipientList;        drl->incStrong((void*)javaObjectForIBinder);        env->SetIntField(object, gBinderProxyOffsets.mOrgue, reinterpret_cast<jint>(drl.get()));        // Note that a new object reference has been created.        android_atomic_inc(&gNumProxyRefs);        incRefsCreated(env);    }    return object;}

在binder.cpp中，checkSubclass默认返回false；在BpBinder中它维护一个KeyedVector来保存当前BpBinder与BinderProxy之间的映射关系，如果前面有绑定过BinderProxy与BpBinder，后面就可以直接通过findObject找到前面绑定的BinderProxy，从而可以获得BpBinder。这里假设是第一次调用，所以会先创建一个BinderProxy对象，然后设置BinderProxy对象的mObject为BpBinder(0)的内存地址；获取BinderProxy对象的mSelf这个WeakReference对象，并调用BpBinder的attachObject将BinderProxy与BpBinder绑定起来，并将mOrgue设置为DeathRecipientList对象的地址。然后返回BinderProxy对象给getIServiceManager()方法。ServiceManagerNative的asInterface方法如下：

    static public IServiceManager asInterface(IBinder obj)    {        if (obj == null) {            return null;        }        IServiceManager in =            (IServiceManager)obj.queryLocalInterface(descriptor);        if (in != null) {            return in;        }                return new ServiceManagerProxy(obj);    }

因为这里的obj就是BinderProxy对象，它的queryLocalInterface返回NULL，所以后面会创建一个ServiceManagerProxy对象。把上面的getIServiceManager就可以改写为：

    private static IServiceManager getIServiceManager() {        if (sServiceManager != null) {            return sServiceManager;        }        // Find the service manager        sServiceManager = new ServiceManagerProxy(BinderProxy);        return sServiceManager;    }

调用getIServiceManager().addService方法实际上就是调用ServiceManagerProxy的addService，下面来看ServiceManagerProxy的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();    }

这里首先申请两个Parcel对象，我们来简单的看一下Parcel的obtain和recycle方法。在Java层的Parcel，维护一个Parcel pool，当用户需要申请Parcel时，就调用Parcel.obtain，当用户用完时，需要调用Parcel.recycle方法让它回到pool中以便后面再使用。

    public static Parcel obtain() {        final Parcel[] pool = sOwnedPool;        synchronized (pool) {            Parcel p;            for (int i=0; i<POOL_SIZE; i++) {                p = pool[i];                if (p != null) {                    pool[i] = null;                    if (DEBUG_RECYCLE) {                        p.mStack = new RuntimeException();                    }                    return p;                }            }        }        return new Parcel(0);    }    public final void recycle() {        if (DEBUG_RECYCLE) mStack = null;        freeBuffer();        final Parcel[] pool;        if (mOwnsNativeParcelObject) {            pool = sOwnedPool;        } else {            mNativePtr = 0;            pool = sHolderPool;        }        synchronized (pool) {            for (int i=0; i<POOL_SIZE; i++) {                if (pool[i] == null) {                    pool[i] = this;                    return;                }            }        }    }

POOL_SIZE为6，表示在一个进程中，最多可以同时申请6个Parcel对象。当第一次申请时，所有的sOwnedPool都为NULL，所以创建Parcel(0)来分配Native层的Parcel对象。

    private Parcel(int nativePtr) {        if (DEBUG_RECYCLE) {            mStack = new RuntimeException();        }        //Log.i(TAG, "Initializing obj=0x" + Integer.toHexString(obj), mStack);        init(nativePtr);    }    private void init(int nativePtr) {        if (nativePtr != 0) {            mNativePtr = nativePtr;            mOwnsNativeParcelObject = false;        } else {            mNativePtr = nativeCreate();            mOwnsNativeParcelObject = true;        }    }

因为nativePtr等于0，所以会调用nativeCreate来创建Native层的Parcel对象，代码在android_os_Parcel.cpp中：

static jint android_os_Parcel_create(JNIEnv* env, jclass clazz){    Parcel* parcel = new Parcel();    return reinterpret_cast<jint>(parcel);}

在mNativePtr就保存中Native层的Parcel对象的地址，当使用完调用recycle时，先调用JNI层的freeBuffer()来释放Native层的Parcel对象所申请的存储数据的内存空间，然后将它自己放到Parcel pool中，这样下一次再用Parcel时，就不要再次分配了。来看一下freeBuffer()的实现：

static void android_os_Parcel_freeBuffer(JNIEnv* env, jclass clazz, jint nativePtr){    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);    if (parcel != NULL) {        parcel->freeData();    }}void Parcel::freeData(){    freeDataNoInit();    initState();}

我们在前面分析过freeDataNoInit的方法，它通过向binder驱动发送BC_FREE_BUFFER命令来释放binder驱动申请的binder_buffer。initState用于恢复初始状态。回到ServiceManagerProxy的addService的方法，与Native层注册Service一样，这里首先写入Strict mode和"android.os.IServiceManager"，然后再写入要注册的Service的名字"wifi"，再写入Service本身，这里我们主要分析下writeInterfaceToken和writeStrongBinder两个方法：

static void android_os_Parcel_writeInterfaceToken(JNIEnv* env, jclass clazz, jint nativePtr,                                                  jstring name){    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);    if (parcel != NULL) {        const jchar* str = env->GetStringCritical(name, 0);        if (str != NULL) {            parcel->writeInterfaceToken(String16(str, env->GetStringLength(name)));            env->ReleaseStringCritical(name, str);        }    }}

nativePtr就是前面在调用android_os_Parcel_create时申请的Native层Parcel对象的地址指针，通过reinterpret_cast将它转换为Parcel对象。然后就调用Native层的Parcel对象的writeInterfaceToken方法，这里比较简单。在来看一下writeStrongBinder方法：

static void android_os_Parcel_writeStrongBinder(JNIEnv* env, jclass clazz, jint nativePtr, jobject object){    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);    if (parcel != NULL) {        const status_t err = parcel->writeStrongBinder(ibinderForJavaObject(env, object));        if (err != NO_ERROR) {            signalExceptionForError(env, clazz, err);        }    }}

前面有说过Binder的构造函数会调用JNI的android_os_Binder_init方法，这里先来分析一下。然后再来分析ibinderForJavaObject方法。

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);}

这里构造一个JavaBBinderHolder对象并把它的地址保存在Binder类的mObject上。接着来看ibinderForJavaObject方法：

sp<IBinder> ibinderForJavaObject(JNIEnv* env, jobject obj){    if (obj == NULL) return NULL;    if (env->IsInstanceOf(obj, gBinderOffsets.mClass)) {        JavaBBinderHolder* jbh = (JavaBBinderHolder*)            env->GetIntField(obj, gBinderOffsets.mObject);        return jbh != NULL ? jbh->get(env, obj) : NULL;    }    if (env->IsInstanceOf(obj, gBinderProxyOffsets.mClass)) {        return (IBinder*)            env->GetIntField(obj, gBinderProxyOffsets.mObject);    }    ALOGW("ibinderForJavaObject: %p is not a Binder object", obj);    return NULL;}

因为WifiService是继承于Binder，首先从WifiSerivce对象的mObject上取出JavaBBinderHolder对象，然后调用它的get方法：

class JavaBBinderHolder : public RefBase{public:    sp<JavaBBinder> get(JNIEnv* env, jobject obj)    {        AutoMutex _l(mLock);        sp<JavaBBinder> b = mBinder.promote();        if (b == NULL) {            b = new JavaBBinder(env, obj);            mBinder = b;            ALOGV("Creating JavaBinder %p (refs %p) for Object %p, weakCount=%d\n",                 b.get(), b->getWeakRefs(), obj, b->getWeakRefs()->getWeakCount());        }        return b;    }    sp<JavaBBinder> getExisting()    {        AutoMutex _l(mLock);        return mBinder.promote();    }private:    Mutex           mLock;    wp<JavaBBinder> mBinder;};

在第一次进入到get方法是mBinder并没有赋值，所以它的promote方法返回NULL，所以这里先创建一个JavaBBinder对象，并赋值给mBinder，然后返回。这里的JavaBBinder是继承于BBinder，所以它是一个Bn端，并实现了onTransact方法。至于如何调用这里的onTransact方法，我们下一章再来分析。这里只需要记住在Binder.java中的mObject变量保存了JavaBBinderHolder对象，在JavaBBinderHolder对象中的mBinder中保存了一个JavaBBinder对象，在JavaBBinder保存了真正的WifiService对象。回到android_os_Parcel_writeStrongBinder函数中，接着调用Native层Parcel的writeStrongBinder方法将上面的JavaBBinder写入。再回到ServiceManagerProxy的addService方法中，接着调用mRemote.transact方法，这里的mRemote就是BinderProxy对象，所以来看BinderProxy的transact，它的实现也在android_util_Binder.cpp中。

static jboolean android_os_BinderProxy_transact(JNIEnv* env, jobject obj,        jint code, jobject dataObj, jobject replyObj, jint flags) // throws RemoteException{    if (dataObj == NULL) {    }    Parcel* data = parcelForJavaObject(env, dataObj);    if (data == NULL) {        return JNI_FALSE;    }    Parcel* reply = parcelForJavaObject(env, replyObj);    if (reply == NULL && replyObj != NULL) {        return JNI_FALSE;    }    IBinder* target = (IBinder*)        env->GetIntField(obj, gBinderProxyOffsets.mObject);    if (target == NULL) {        jniThrowException(env, "java/lang/IllegalStateException", "Binder has been finalized!");        return JNI_FALSE;    }    ALOGV("Java code calling transact on %p in Java object %p with code %d\n",            target, obj, code);    status_t err = target->transact(code, *data, reply, flags);    if (err == NO_ERROR) {        return JNI_TRUE;    } else if (err == UNKNOWN_TRANSACTION) {        return JNI_FALSE;    }    signalExceptionForError(env, obj, err, true /*canThrowRemoteException*/);    return JNI_FALSE;}

首先取出data和reply两个Parcel对象，然后从BinderProxy的mObject处取出BpBinder(0)，然后调用它的transact方法，到这里就全部回到Native层注册Servcie的流程了。