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层看到下面的数据关系：

结构体	变量名	解释
gBinderOffsets	mClass	保存Binder.class的ref
	mExecTransact	保存Binder.class的execTransact函数ID
	mObject	保存Binder.class的mObject成员ID，实际保存JavaBBinderHolder的地址
gBinderInternalOffsets	mClass	保存BinderInternal.class的ref
	mForceGc	保存BinderInternal.class的forceBinderGc函数ID
gBinderProxyOffsets	mClass	保存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的流程了。