源碼基于：Android R

0. 前言

在闡述相關(guān)的知識點，先整理個框架圖，后面帶著框架圖來分析過程：

Java 端對于binder 使用大致分為：

• Java client Java service
• Java client native service

Java 端service 的注冊使用 ServiceManager.addService()

Java 端service 的獲取使用 ServiceManager.getService()

入口都是通過 ServiceManager.java，文件位于frameworks/base/core/java/android/os/ServiceManager.java

在分析addService 和getService 之前，需要了解Binder 最終是會調(diào)用到native 端，那么，Java 中間就需要通過JNI，所以在此之前需要了解JNI 的注冊過程。

1. Binder JNI 注冊

了解zygote 啟動過程的同學(xué)應(yīng)該知道 zygote 在啟動時首先會創(chuàng)建虛擬機，然后再通過 startReg() 注冊系統(tǒng)所需要的JNI 接口。

frameworks/base/core/jni/AndroidRuntime.cpp

/*static*/ int AndroidRuntime::startReg(JNIEnv* env)
{
    ...
    if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
        env->PopLocalFrame(NULL);
        return -1;
    }
    ...
}

注冊的接口定義在：

frameworks/base/core/jni/AndroidRuntime.cpp

static const RegJNIRec gRegJNI[] = {
        REG_JNI(register_com_android_internal_os_RuntimeInit),
        REG_JNI(register_com_android_internal_os_ZygoteInit_nativeZygoteInit),
        REG_JNI(register_android_os_SystemClock),
        REG_JNI(register_android_util_EventLog),
        REG_JNI(register_android_util_Log),
        REG_JNI(register_android_util_MemoryIntArray),
        ...
        REG_JNI(register_android_os_Binder),
        ...

數(shù)組很長，這里不過多粘貼，binder 相關(guān)的注冊函數(shù)有：

        REG_JNI(register_android_os_Binder),

最終會調(diào)用到函數(shù)register_android_os_Binder()：

frameworks/base/core/jni/android_util_Binder.cpp

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;
    ...

剩下來就不過多分析了，感興趣的同學(xué)可以進入詳細查看源碼流程 (當(dāng)然，下面遇到也會順帶分析下)，這里只需要知道的是Java 端的Binder 需要native 操作的JNI 接口都是在zygote 啟動時就注冊好了。

2. ServiceManager 的代理

無論是ServiceManager.addService() 還是ServiceManager.getService() 最終都是需要與native 通信，那需要獲取到 ServiceManager 的代理。即函數(shù) getIServiceManager()：

frameworks/base/core/java/android/os/ServiceManager.java 

    private static IServiceManager getIServiceManager() {
        if (sServiceManager != null) {
            return sServiceManager;
        }

        // Find the service manager
        sServiceManager = ServiceManagerNative
                .asInterface(Binder.allowBlocking(BinderInternal.getContextObject()));
        return sServiceManager;
    }

這里主要關(guān)注兩點：

• BidnerInternal.getcontextObject()
• ServiceManagerNative.asInterface()

2.1 BinderInternal.getContextObject()

frameworks/base/core/java/com/android/internal/os/BinderInternal.java

public static final native IBinder getContextObject();

這個需要調(diào)用 JNI 接口，而這個接口注冊在第 1 節(jié)已經(jīng)闡述過，詳細看int_register_android_os_BinderInternal()：

frameworks/base/core/jin/android_util_Binder.cpp

static const JNINativeMethod gBinderInternalMethods[] = {
     /* name, signature, funcPtr */
    { "getContextObject", "()Landroid/os/IBinder;", (void*)android_os_BinderInternal_getContextObject },
    ...
    }
};
static int int_register_android_os_BinderInternal(JNIEnv* env)
{
    ...
    return RegisterMethodsOrDie(
env, kBinderInternalPathName,
 gBinderInternalMethods, NELEM(gBinderInternalMethods));
}

通過注冊 gBinderInternalMethods 數(shù)組得知，最終調(diào)用接口android_os_BinderInternal_getContextObject()：

frameworks/base/core/jin/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);
}

這里很熟悉了，獲取的是 context 為 0 的servicemanager 的BpBinder，并將BpBinder 通過函數(shù)javaObjectForIBinder()?轉(zhuǎn)換成Java 的 BinderProxy 對象返回。

2.1.1?javaObjectForIBinder()

frameworks/base/core/jin/android_util_Binder.cpp

jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val)
{
    ...
    BinderProxyNativeData* nativeData = new BinderProxyNativeData();
    nativeData->mOrgue = new DeathRecipientList;
    nativeData->mObject = val;

    jobject object = env->CallStaticObjectMethod(gBinderProxyOffsets.mClass,
            gBinderProxyOffsets.mGetInstance, (jlong) nativeData, (jlong) val.get());
    if (env->ExceptionCheck()) {
        // In the exception case, getInstance still took ownership of nativeData.
        return NULL;
    }
    ...

    return object;
}

這里主要通過CallStaticObjectMethod() 調(diào)用BinderProxy 中的 geInstance()，而這里的全局對象 gBinderProxyOffsets 是在 int_register_android_os_BinderProxy() 中指定的：

frameworks/base/core/jin/android_util_Binder.cpp

static int int_register_android_os_BinderProxy(JNIEnv* env)
{
    gErrorOffsets.mError = MakeGlobalRefOrDie(env, FindClassOrDie(env, "java/lang/Error"));
    gErrorOffsets.mOutOfMemory =
        MakeGlobalRefOrDie(env, FindClassOrDie(env, "java/lang/OutOfMemoryError"));
    gErrorOffsets.mStackOverflow =
        MakeGlobalRefOrDie(env, FindClassOrDie(env, "java/lang/StackOverflowError"));

    jclass clazz = FindClassOrDie(env, kBinderProxyPathName);
    gBinderProxyOffsets.mClass = MakeGlobalRefOrDie(env, clazz);
    gBinderProxyOffsets.mGetInstance = GetStaticMethodIDOrDie(env, clazz, "getInstance",
            "(JJ)Landroid/os/BinderProxy;");
    gBinderProxyOffsets.mSendDeathNotice =
            GetStaticMethodIDOrDie(env, clazz, "sendDeathNotice",
                                   "(Landroid/os/IBinder$DeathRecipient;Landroid/os/IBinder;)V");
    gBinderProxyOffsets.mNativeData = GetFieldIDOrDie(env, clazz, "mNativeData", "J");

    clazz = FindClassOrDie(env, "java/lang/Class");
    gClassOffsets.mGetName = GetMethodIDOrDie(env, clazz, "getName", "()Ljava/lang/String;");

    return RegisterMethodsOrDie(
        env, kBinderProxyPathName,
        gBinderProxyMethods, NELEM(gBinderProxyMethods));
}

javaObjectForIBinder() 需要通過 CallStaticObjectMethod() 函數(shù)調(diào)用?BinderProxy 的 getInstance() 接口，來看下：

frameworks/base/core/java/android/os/BinderProxy.java

    private static BinderProxy getInstance(long nativeData, long iBinder) {
        BinderProxy result;
        synchronized (sProxyMap) {
            try {
                result = sProxyMap.get(iBinder);
                if (result != null) {
                    return result;
                }
                result = new BinderProxy(nativeData);
            } catch (Throwable e) {
                ...
            }
            ...
        }
        return result;
    }

至此，可知?BidnerInternal.getcontextObject() 獲取的是context 為0 的 BinderProxy 對象。

2.2?ServiceManagerNative.asInterface()

framworks/base/core/java/android/os/ServiceManagerNative.java

    public static IServiceManager asInterface(IBinder obj) {
        if (obj == null) {
            return null;
        }

        // ServiceManager is never local
        return new ServiceManagerProxy(obj);
    }

BinderProxy 對象獲取到后，通過asInterface，創(chuàng)建ServiceManager 的Java 端代理ServiceManagerProxy：

framworks/base/core/java/android/os/ServiceManagerNative.java

class ServiceManagerProxy implements IServiceManager {
    public ServiceManagerProxy(IBinder remote) {
        mRemote = remote;
        mServiceManager = IServiceManager.Stub.asInterface(remote);
    }
    ...
    public void addService(String name, IBinder service, boolean allowIsolated, int dumpPriority)
            throws RemoteException {
        mServiceManager.addService(name, service, allowIsolated, dumpPriority);
    }
    ...
    private IBinder mRemote;
    private IServiceManager mServiceManager;
}

mRemote 為BinderProxy 對象，mServiceManager 則是所有接口的入口，ServiceManager的真正proxy，下面會繼續(xù)分析。

3. ServiceManager.addService()

通過第 2 節(jié)，我們得知，Java 端進行binder 通信，可能是client 通過ServiceManager.getService()?獲取到的server 代理，也可能是server 端通過ServiceManager.addService() 將service 注冊到ServiceManager 中。但無論哪個接口，都是通過ServiceManager 在java 端的代碼 BinderProxy 進行操作的。

這一節(jié)分析下addService()：

frameworks/base/core/java/android/os/ServiceManager.java 

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

getIServiceManager() 就是上面第 2.2 節(jié)返回的ServiceManagerProxy 對象，如果上面 2.2 節(jié)代碼所示，addService() 最終調(diào)用的是 mServiceManager.addService()，而這個mServiceManager 則是將上文講到的context 0 的BinderProxy 對象作為參數(shù)帶入通過IServiceManager 獲取的代理：

 mServiceManager = IServiceManager.Stub.asInterface(remote);

繼續(xù)分析。

通常andorid 都會將 *.aidl 文件編譯成對應(yīng)的 java 文件，而最終的 java 源碼是在out/soong/.intermediates/ 下，詳細看本系列文章中的第七篇：Java 下的C-S

aidl 編譯后的JAVA 文件都會最終打包到aidl*.srcjar 中，那具體的文件怎么確定呢？需要依賴frameworks 文件夾或者system 文件夾的 *.aidl.d 文件。

如果aidl 文件是定義在frameworks 下，那么就可以到framework 下對應(yīng)的目錄查找對應(yīng)的 *.aidl.d 文件。

這個的 IServiceManager 就是 IServiceManager.aidl 編譯后的類名

      @Override public void addService(java.lang.String name, android.os.IBinder service, boolean allowIsolated, int dumpPriority) 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.writeStrongBinder(service);
          ...
          boolean _status = mRemote.transact(Stub.TRANSACTION_addService, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            getDefaultImpl().addService(name, service, allowIsolated, dumpPriority);
            return;
          }
          _reply.readException();
        }
        ...
      }

proxy 的代碼比較簡單：

• 通過接口writeStrongBinder() 將需要添加的 service 寫到 Parcel 中；
• 通過mRemote.transact() 進行通信，確認是否達到addService() 目的；
• 如果上面失敗，則嘗試通過 getDefaultImpl() 進行 addService()；

通常是走第二步，第三步的default impl 需要通過接口 setDefaultImpl() 指定。

通過第 2.2 節(jié)獲悉，mRemote 就是ServiceManager 的java 端BinderProxy 對象。

3.1 writeStrongBinder()

frameworks/base/core/java/android/os/Parcel.java

    public final void writeStrongBinder(IBinder val) {
        nativeWriteStrongBinder(mNativePtr, val);
    }

JNI 接口位于android_os_Parcel.cpp 中，而此接口也是在zygote 啟動是加載。這里不過多分析，詳細請查看 AndroidRuntime.cpp 中數(shù)組 gRegJNI 里的成員 register_android_os_Parcel。

最終調(diào)用到JNI android_os_Parcel_writeStrongBinder()：

frameworks/base/core/jni/android_os_Parcel.cpp

static void android_os_Parcel_writeStrongBinder(JNIEnv* env, jclass clazz, jlong 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);
        }
    }
}

來看下核心的 ibinderForJavaObject()：

frameworks/base/core/jni/android_util_Binder.cpp

sp<IBinder> ibinderForJavaObject(JNIEnv* env, jobject obj)
{
    if (obj == NULL) return NULL;

    // Instance of Binder?
    if (env->IsInstanceOf(obj, gBinderOffsets.mClass)) {
        JavaBBinderHolder* jbh = (JavaBBinderHolder*)
            env->GetLongField(obj, gBinderOffsets.mObject);
        return jbh->get(env, obj);
    }

    // Instance of BinderProxy?
    if (env->IsInstanceOf(obj, gBinderProxyOffsets.mClass)) {
        return getBPNativeData(env, obj)->mObject;
    }

    ALOGW("ibinderForJavaObject: %p is not a Binder object", obj);
    return NULL;
}

純正的service 屬于 Binder 類型，所以匹配時與gBinderOffsets.mClass 匹配，該變量是也是在注冊的時候賦值，詳細看 int_register_android_os_Binder()。

gBinderOffsets.mObject 獲取的是 Binder.java 中的 mObject 對象(詳細看int_register_android_os_Binder函數(shù))，也就是在Binder 構(gòu)造時，從native 獲取的 BBinderHolder 指針：

frameworks/base/core/java/android/os/Binder.java

    public Binder(@Nullable String descriptor)  {
        mObject = getNativeBBinderHolder();

        ...
    }

---->?

frameworks/base/core/jni/android_util_Binder.cpp

static jlong android_os_Binder_getNativeBBinderHolder(JNIEnv* env, jobject clazz)
{
    JavaBBinderHolder* jbh = new JavaBBinderHolder();
    return (jlong) jbh;
}

ibinderForJavaObject() 除了上面獲取到的JavaBBinderHolder，最終就是通過該 holder 調(diào)用 get()接口，獲取 servcie 的BBinder：

frameworks/base/core/jni/android_util_Binder.cpp

    sp<JavaBBinder> get(JNIEnv* env, jobject obj)
    {
        AutoMutex _l(mLock);
        sp<JavaBBinder> b = mBinder.promote();
        if (b == NULL) {
            b = new JavaBBinder(env, obj);
            ...
        }

        return b;
    }

來看下JavaBBinder：

frameworks/base/core/jni/android_util_Binder.cpp

class JavaBBinder : public BBinder
{
    ...
}

所以，writeStrongBinder() 最終就是 native 中 BBinder 寫入parcel 傳入transact()。

3.2 BinderProxy.transact()

詳細看第 5節(jié)

3.3 JavaBBinder.onTransact()

當(dāng)Client 通過 transact() 進行通信時，最終 BBinder 會觸發(fā)onTransact()，對于java service，最終觸發(fā)的就是 JavaBBinder.onTransact()：

frameworks/base/core/jni/android_util_Binder.cpp

    status_t onTransact(
        uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags = 0) override
    {
        ...
        jboolean res = env->CallBooleanMethod(mObject, gBinderOffsets.mExecTransact,
            code, reinterpret_cast<jlong>(&data), reinterpret_cast<jlong>(reply), flags);

gBinderOffsets.mExecTransact 也是int_register_android_os_Binder() 賦值，調(diào)用的是Binder.java 中execTransact()，這里不過多闡述，最終調(diào)用stub.onTransact。

4. ServiceManager.getService()

同addService，getService 最終也是調(diào)用到IServiceManager中：

      @Override public android.os.IBinder checkService(java.lang.String name) throws android.os.RemoteException
      {
        android.os.Parcel _data = android.os.Parcel.obtain();
        android.os.Parcel _reply = android.os.Parcel.obtain();
        android.os.IBinder _result;
        try {
          ...
          boolean _status = mRemote.transact(Stub.TRANSACTION_checkService, _data, _reply, 0);
          if (!_status && getDefaultImpl() != null) {
            return getDefaultImpl().checkService(name);
          }
          _reply.readException();
          _result = _reply.readStrongBinder();
        }
        finally {
          _reply.recycle();
          _data.recycle();
        }

        return _result;
      }

同理addService()，這里會通過 _reply.readStrongBinder() 獲得native 端傳過來的binder 信息。

4.1?readStrongBinder()

最終會調(diào)用到JNI android_os_Parcel.cpp

frameworks/base/core/jni/android_os_Parcel.cpp

static jobject android_os_Parcel_readStrongBinder(JNIEnv* env, jclass clazz, jlong nativePtr)
{
    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr);
    if (parcel != NULL) {
        return javaObjectForIBinder(env, parcel->readStrongBinder());
    }
    return NULL;
}

第 2.1 節(jié)已經(jīng)分析過了，最終通過javaObjectForIBinder() 獲取到 service 在java 端的BinderProxy 對象。

5.?BinderProxy.transact()

frameworks/base/core/java/android/os/BinderProxy.java

    public boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
        Binder.checkParcel(this, code, data, "Unreasonably large binder buffer");

        ....
        try {
            return transactNative(code, data, reply, flags);
        } finally {
            ...
        }
    }

其實這里核心就是調(diào)用transactNative：

frameworks/base/core/jni/android_util_Binder.cpp

static jboolean android_os_BinderProxy_transact(JNIEnv* env, jobject obj,
        jint code, jobject dataObj, jobject replyObj, jint flags) // throws RemoteException
{
    ...

    status_t err = target->transact(code, *data, reply, flags);
    ...
}

接下來就是BpBinder->transact，看詳細看本系列文章中的第三篇：service 注冊

6. 總結(jié)?

最后再來根據(jù)框架圖進行總結(jié)：文章來源地址http://www.zghlxwxcb.cn/news/detail-503464.html

• Java client 通過getService() 獲取service 的代理，getService() 最后會通過readStrongBinder()?獲取 BinderProxy 對象；
• Java client 通過transact 與service 通信，通過native 接口 transactNative() 調(diào)用到BpBinder；
• Java service 通過addService() 注冊，addService() 會通過writeStrongBinder() 調(diào)用native 接口注冊到JNI；
• Java service 注冊時，會在JNI 中創(chuàng)建 JavaBBinderHolder，這里封裝了與 native 通信的JavaBBinder，而JavaBBinder 就是繼承自BBinder；
• Java client 的調(diào)用對于 java service 最終會調(diào)用 onTransact()，并回調(diào)到j(luò)ava 端stub.onTransact()；

到了這里，關(guān)于Android Binder通信原理(五)：Java 端的service 注冊和獲取的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！