Android IPC Binder机制学习（一）

一、多进程系统设计及意义

Android系统分为5层，不过Android一般岗位只关注上三层就够用了即：应用层、framework层、native层。

1. Android中的应用层和系统服务层不在同一个进程，系统服务在单独的进程中。

2. Android中不同的应用属于不同的进程中

Android应用和系统服务运行在不同的进程中是为了安全、稳定、及内存管理的原因，但应用和系统服务需要通信和分享数据。

优点

• 安全性：每个进程都可以单独运行，可以保证应用层对系统层的隔离。

• 稳定性：如果某个进程崩溃了不会导致其他进程崩溃

• 内存分配：如果某个进程已经不需要了，可以从能存中移除，并回收相应的内存。

以上优点都是将系统设计成多进程的原因，我们在开发App时，也可以根据需要将App也设计成多进程的，比如以下场景：

虚拟机分配给各个进程的运行内存是有限的，LMK也会优先回收对系统资源占用多的进程。

• 突破进程内存限制，如图库占用内存过多

• 功能稳定性：独立的通信进程保持长连接的稳定性（如：微信的消息推送功能跑在独立的进程）

• 规避系统内存泄漏：独立的webview进程阻隔内存泄漏导致的问题

• 隔离风险：对于不稳定的功能放入独立的进程，避免导致主进程崩溃

二、Android/Linux都有哪些进程间通信方式？Android为什么主要采用Binder作为进程间的通信方式？

1. 内存共享

2. 管道

3. 消息队列

4. socket

5. binder

疑问1：共享内存和内存映射有什么区别？

共享内存可以直接创建，内存映射需要磁盘文件（匿名映射除外）

内存映射用于文件读写：当多个进程映射到同一个文件时，并且设置了MAP_SHARE，此时可以IPC，不过数据会写回磁盘，所以还是共享内存快。

疑问2：为什么binder通信要将数据拷贝到内核空间，再由内核空间和server端做内存映射，而不是client和server直接做内存映射？

答：有两点1是拷贝到内核会对uid和pid等进行身份检测，权限安全，2是有一次拷贝，这就是个单向操作，server端哪怕修改了内存映射中的数据，也不会影响到client端中的数据，保证数据安全。

各种方式对比

三、Binder通信模型（以请求系统服务为例如ActivityManagerService）

1. Android系统服务在启动后会将自己注册到ServiceManager，ServiceManager维护了一个表来存储各种系统服务的名字和binder（系统服务名和系统服务的binder（可理解为系统服务的句柄）是对应关系）。

2. 客户度想要请求系统服务时，要向serviceManager中传对应的系统服务名来获取对应的系统服务Binder。

3. 客户端有了系统服务的binder就可以通过Binder驱动向系统服务发送数据，从而完成了跨进程通信。

4. 客户端向服务端发送的数据中会携带客户端的binder，这样服务端如果有数据需要返回给客户端，就可以通过客户端的binder来实现。

四、Binder是怎么创建的？

1.要讨论Binder是怎么创建的，需要先清楚Binder是什么？

在Android中我们所使用的Activity，Service等组件都需要和AMS通信，这种跨进程的通信都是通过Binder完成的。

• 机制：Binder是一种进程间的通信机制

• 驱动：Binder是一个虚拟物理设备驱动

• 应用层：Binder是一个能发起通信的Java类

• Framework/native:Binder连接了Client、Server、ServiceManager和Binder驱动程序，形成一套C/S的通信架构

2.Binder是什么时候创建的呢？

在进程创建的时候，就准备了binder

以Service Manager进程为例：

//文件路径：frameworks\native\cmds\servicemanager\main.cpp
int main(int argc, char** argv) {
    if (argc > 2) {
        LOG(FATAL) << "usage: " << argv[0] << " [binder driver]";
    }

    //此时要使用的binder驱动为 "/dev/binder"
    const char* driver = argc == 2 ? argv[1] : "/dev/binder";
    //初始化binder驱动
    sp<ProcessState> ps = ProcessState::initWithDriver(driver);
    ps->setThreadPoolMaxThreadCount(0);
    ps->setCallRestriction(ProcessState::CallRestriction::FATAL_IF_NOT_ONEWAY);
    //实例化ServiceManager
    sp<ServiceManager> manager = new ServiceManager(std::make_unique<Access>());
    //将自身作为服务添加
    if (!manager->addService("manager", manager, false /*allowIsolated*/, IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT).isOk()) {
        LOG(ERROR) << "Could not self register servicemanager";
    }
    //设置服务端Bbinder对象
    IPCThreadState::self()->setTheContextObject(manager);
    //设置称为binder驱动的context manager，称为上下文的管理者
    ps->becomeContextManager(nullptr, nullptr);
    //通过Looper epoll机制处理binder事务
    sp<Looper> looper = Looper::prepare(false /*allowNonCallbacks*/);

    BinderCallback::setupTo(looper);
    ClientCallbackCallback::setupTo(looper, manager);

    while(true) {
        looper->pollAll(-1);
    }

    // should not be reached
    return EXIT_FAILURE;
}

五、Binder的使用

通常我们使用Binder并不是直接使用，因为Binder的使用较为复杂容易出问题，由此Android官方出了一个对Binder的封装框架即AIDL。

可以先看下AIDL的简单使用

通过AIDL文件生成的接口中，内部类Stub提供了服务端提供的服务的实现逻辑，Proxy是Stub的代理类，用于给客户端提供调用服务端Stub的句柄。在使用demo中也能看到AIDL文件在客户端和服务端中都要用到（且内容相同），但在客户端与服务端中使用的部分是不一样的，Proxy是给客户端使用的，Stub是服务端使用的，或者说Stub是服务端所持有的。（注意这个service不是我们自己的service而是AMS）

六、Binder跨进程传递数据的详细流程

上图概括出了从Activity要拿到我们自己service的Binder的过程，要经过8次跨进程通信

这里我们以上图中①处的从App进程到servicemanager进程获取AMS的IBinder的操作为例，来具体分析Binder跨进程通信的过程。其中会涉及servicemanager的启动流程相关的内容，不熟悉的小伙伴可以先看一下。

1. 客户端发送请求数据到内核中的Binder驱动

//入口代码
Activity中调用startService()

//最终会调用到ContextImpl.java中的
private ComponentName startServiceCommon(Intent service, boolean requireForeground,
            UserHandle user) {
        try {
            validateServiceIntent(service);
            service.prepareToLeaveProcess(this);
            // ActivityManager.getService() 就是本小节分析的重点，跨进程获取AMS的IBinder
            ComponentName cn = ActivityManager.getService().startService(
                    mMainThread.getApplicationThread(), service,
                    service.resolveTypeIfNeeded(getContentResolver()), requireForeground,
                    getOpPackageName(), getAttributionTag(), user.getIdentifier());
        ...
}

// ActivityManager.java
@UnsupportedAppUsage
    public static IActivityManager getService() {
        return IActivityManagerSingleton.get();
}

private static final Singleton<IActivityManager> IActivityManagerSingleton =
            new Singleton<IActivityManager>() {
                @Override
                protected IActivityManager create() {
                    //这里正式进入主题，这行代码大家都很熟悉吧
                    final IBinder b = ServiceManager.getService(Context.ACTIVITY_SERVICE);
                    final IActivityManager am = IActivityManager.Stub.asInterface(b);
                    return am;
                }
            };

//ServiceManager.java

public static IBinder getService(String name) {
        try {
            IBinder service = sCache.get(name);
            if (service != null) {
                return service;
            } else {
                //缓存中到不到，走这里
                return Binder.allowBlocking(rawGetService(name));
            }
        } catch (RemoteException e) {
            Log.e(TAG, "error in getService", e);
        }
        return null;
    }

 // name是一层层传递进来的，ACTIVITY_SERVICE = "activity"
 private static IBinder rawGetService(String name) throws RemoteException {
        final long start = sStatLogger.getTime();
        //这里分为两步
        // step1：getIServiceManager() 拿到servicemanager的IBinder
        // step2：getService(name) 这一步就是跨进程通信了
        final IBinder binder = getIServiceManager().getService(name);
        ...
        return binder;
 }

 //----------------------先看step1:---------------------------
 private static IServiceManager getIServiceManager() {
        //不为空直接返回
        if (sServiceManager != null) {
            return sServiceManager;
        }

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

  //先看注解2：    BinderInternal.java
  //是个native方法，由此进入native层源码
  public static final native IBinder getContextObject();

//寻找getContextObject()对应对的native方法，了解过Android系统启动流程的小伙伴知道在启动zygote进程的
//时候（frameworks\base\cmds\app_process\app_main.cpp），有一个非常重要的步骤就是会进行一系列的jni方法注册，
//我们来具体看下
//main方法
int main(int argc, char* const argv[])
{
    ...
     if (zygote) {
        //启动运行时环境
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
      }
}

//进入start()      frameworks\base\core\jni\AndroidRuntime.cpp
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ...
    if (startReg(env) < 0) {  //注册JNI
        ALOGE("Unable to register all android natives\n");
        return;
    }
    ...
} 

int AndroidRuntime::startReg(JNIEnv* env)
{
   
    ...
    // gRegJNI 是定义好的jni方法 相关的结构体数组，系统中所有需要动态加载的jni方法都在这了
    if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
        env->PopLocalFrame(NULL);
        return -1;
    }
    ...

    return 0;
}

static const RegJNIRec gRegJNI[] = {
   ...
   //这个也有一定的规律，我们要寻找的BinderProxy.transactNative（）的包名就是android.os,它是binder相关的jni
   REG_JNI(register_android_os_Binder),  
   ...
}
//   frameworks\base\core\jni\android_util_Binder.cpp  进入register_android_os_Binder这个方法
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) //在这个方法里注册BinderInternal.java中的native方法
        return -1;
    if (int_register_android_os_BinderProxy(env) < 0) 
        return -1;
    ...
}

//看和java类对应上了吧
const char* const kBinderInternalPathName = "com/android/internal/os/BinderInternal";
static int int_register_android_os_BinderInternal(JNIEnv* env)
{
     ... 
    return RegisterMethodsOrDie(
        env, kBinderInternalPathName,
        gBinderInternalMethods, NELEM(gBinderInternalMethods));
}

//重点在这里，这个数组中写死了java方法与native方法的对应关系，（jni动态注册）
static const JNINativeMethod gBinderInternalMethods[] = {
     /* name, signature, funcPtr */
    //android_os_BinderInternal_getContextObject就是我们要找的native方法
    { "getContextObject", "()Landroid/os/IBinder;", (void*)android_os_BinderInternal_getContextObject },
    { "joinThreadPool", "()V", (void*)android_os_BinderInternal_joinThreadPool },
    { "disableBackgroundScheduling", "(Z)V", (void*)android_os_BinderInternal_disableBackgroundScheduling },
    { "setMaxThreads", "(I)V", (void*)android_os_BinderInternal_setMaxThreads },
    { "handleGc", "()V", (void*)android_os_BinderInternal_handleGc },
    { "nSetBinderProxyCountEnabled", "(Z)V", (void*)android_os_BinderInternal_setBinderProxyCountEnabled },
    { "nGetBinderProxyPerUidCounts", "()Landroid/util/SparseIntArray;", (void*)android_os_BinderInternal_getBinderProxyPerUidCounts },
    { "nGetBinderProxyCount", "(I)I", (void*)android_os_BinderInternal_getBinderProxyCount },
    { "nSetBinderProxyCountWatermarks", "(II)V", (void*)android_os_BinderInternal_setBinderProxyCountWatermarks}
};

static jobject android_os_BinderInternal_getContextObject(JNIEnv* env, jobject clazz)
{
    sp<IBinder> b = ProcessState::self()->getContextObject(NULL);
    //将b转成java中的对象
    return javaObjectForIBinder(env, b);  //注解3
}

//frameworks\native\libs\binder\ProcessState.cpp
sp<IBinder> ProcessState::getContextObject(const sp<IBinder>& /*caller*/)
{
    sp<IBinder> context = getStrongProxyForHandle(0);
    ...
    return context;
}

sp<IBinder> ProcessState::getStrongProxyForHandle(int32_t handle)
{
    ...
    handle_entry* e = lookupHandleLocked(handle);

    if (e != nullptr) {
        IBinder* b = e->binder;
        if (b == nullptr || !e->refs->attemptIncWeak(this)) {
            // //创建BpBinder并保存下来以便后面再次查找
            //ServiceManager 服务比较特殊，其BBinder（服务)保存在IPCThreadState中(the_context_object)，对应的handle 是0；
            //ServiceManager的BBinder在每一个进程中的handle值都为0。因此，任何进程和ServiceManager进程的通信便不再需要事先获取它的代理对象，
            //而只需要告诉Binder Driver：我需要和handle值为0的进程通信。Binder Driver便会自动将该进程的通信请求转发到ServiceManager进程。 
            b = BpBinder::create(handle);
            e->binder = b;
            if (b) e->refs = b->getWeakRefs();
            result = b;
     }
   ...
   }
    //最终将servicemanager的BBinder的代理对象BpBinder返回了出去
    return result;
}

//接下来看注解3处的流程，将得到的BpBinder转换成Java层使用的对象
// 将一个BpBinder对象（这是native中的类型）转换成java中的类型
jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val)
{
     ...
     //通过反射创建java 对应的BpBinder对象（BinderProxy）
     jobject object = env->CallStaticObjectMethod(gBinderProxyOffsets.mClass,
            gBinderProxyOffsets.mGetInstance, (jlong) nativeData, (jlong) val.get());
     ...
}

//gBinderProxyOffsets.mClass就是反射创建对象的类型，它是在下面的方法中被赋值的
const char* const kBinderProxyPathName = "android/os/BinderProxy";

static int int_register_android_os_BinderProxy(JNIEnv* env)
{
    ...
    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");
    ...
}


/**回到注解2处,我们知道BinderInternal.getContextObject() = BinderProxy对象
  *实质上是servicemanager进程中创建的BBinder对象
  *                                java层 | native层                     
  *封装关系ServicemanagerProxy->BinderProxy->BpBinder == BBinder
  *此时再来看注释1处,其实就是
  *sServiceManager = ServiceManagerNative.asInterface(BinderProxy对象) //伪代码
 **/
//ServiceManagerNative.java

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

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

//java层的servicemanager的IBinder代理类

class ServiceManagerProxy implements IServiceManager {
    public ServiceManagerProxy(IBinder remote) {
        mRemote = remote;  //BinderProxy
        //熟悉AIDL的小伙伴应该知道，IServiceManager这个类就是通过IServiceManager.aidl文件生成的,下面会给出这个文件
        mServiceManager = IServiceManager.Stub.asInterface(remote);
    }

    //注意，后面step2就是走到这个方法
    public IBinder getService(String name) throws RemoteException {
        // Same as checkService (old versions of servicemanager had both methods).
        return mServiceManager.checkService(name);
    }

    private IBinder mRemote;
    private IServiceManager mServiceManager;  //IServiceManager.Stub.Proxy类型
}

//---------------------------step2----------------------------
/**回到step2处，
  *private static IBinder rawGetService(String name) throws RemoteException {
        final long start = sStatLogger.getTime();
        //这里分为两步
        // step1：getIServiceManager() 拿到servicemanager的IBinder
        // step2：getService(name) 这一步就是跨进程通信了
        //由上可知getIServiceManager() = ServiceManagerNative.ServiceManagerProxy对象
        final IBinder binder = getIServiceManager().getService(name);
        ...
        return binder;
    }
**/

//getService(name)会调到ServiceManagerNative.ServiceManagerProxy.getService()
public IBinder getService(String name) throws RemoteException {
        //mServiceManager是IServiceManager.Stub.Proxy类型的对象
        return mServiceManager.checkService(name);
}

//为了方便分析，我们可以使用aidl工具将IserviceManager.aidl的java类生成出来：
//内容较多只截取当前需要的部分代码
public interface IServiceManager extends android.os.IInterface
{
 
  /** Local-side IPC implementation stub class. */
  public static abstract class Stub extends android.os.Binder implements android.os.IServiceManager
  {
    private static final java.lang.String DESCRIPTOR = "android.os.IServiceManager";
    /** Construct the stub at attach it to the interface. */
    public Stub()
    {
      this.attachInterface(this, DESCRIPTOR);
    }
    /**
     * Cast an IBinder object into an android.os.IServiceManager interface,
     * generating a proxy if needed.
     */
    public static android.os.IServiceManager asInterface(android.os.IBinder obj)
    {
      if ((obj==null)) {
        return null;
      }
      android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
      if (((iin!=null)&&(iin instanceof android.os.IServiceManager))) {
        return ((android.os.IServiceManager)iin);
      }
      return new android.os.IServiceManager.Stub.Proxy(obj);
    }
    @Override public android.os.IBinder asBinder()
    {
      return this;
    }
    
    private static class Proxy implements android.os.IServiceManager
    {
      private android.os.IBinder mRemote; //BinderProxy
      Proxy(android.os.IBinder remote)
      {
        mRemote = remote;
      }
      @Override public android.os.IBinder asBinder()
      {
        return mRemote;
      }
      public java.lang.String getInterfaceDescriptor()
      {
        return DESCRIPTOR;
      }
      
      
      @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 {
          _data.writeInterfaceToken(DESCRIPTOR);
          _data.writeString(name);
          //_data中写入了我们传的那么参数，mRemote的类型是BinderProxy,TRANSACTION_checkService代表当前要跨进程执行的是checkService()这个函数        
          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;
      }
      
      public static android.os.IServiceManager sDefaultImpl;
    }
    static final int TRANSACTION_getService = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
    static final int TRANSACTION_checkService = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
   
}

//来到BinderProxy类的transact()
public boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
       ...
        try {
            //主线流程来到transactNative(),他是一个native方法，
            final boolean result = transactNative(code, data, reply, flags);

            if (reply != null && !warnOnBlocking) {
                reply.addFlags(Parcel.FLAG_IS_REPLY_FROM_BLOCKING_ALLOWED_OBJECT);
            }

            return result;
        } 
        ...
 }

//由此将从java层调用到native层
public native boolean transactNative(int code, Parcel data, Parcel reply,
            int flags) throws RemoteException;


//4.寻找transactNative()对应对的native方法，了解过Android系统启动流程的小伙伴知道在启动zygote进程的
//时候（frameworks\base\cmds\app_process\app_main.cpp），有一个非常重要的步骤就是会进行一系列的jni方法注册，
//我们来具体看下：
//main方法
int main(int argc, char* const argv[])
{
    ...
     if (zygote) {
        //启动运行时环境
        runtime.start("com.android.internal.os.ZygoteInit", args, zygote);
      }
}

//进入start()      frameworks\base\core\jni\AndroidRuntime.cpp
void AndroidRuntime::start(const char* className, const Vector<String8>& options, bool zygote)
{
    ...
    if (startReg(env) < 0) {  //注册JNI
        ALOGE("Unable to register all android natives\n");
        return;
    }
    ...
} 

int AndroidRuntime::startReg(JNIEnv* env)
{ 
    ...
    // gRegJNI 是定义好的jni方法 相关的结构体数组，系统中所有需要动态加载的jni方法都在这了
    if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) {
        env->PopLocalFrame(NULL);
        return -1;
    }
    ...

    return 0;
}

static const RegJNIRec gRegJNI[] = {
   ...
   //这个也有一定的规律，我们要寻找的BinderProxy.transactNative（）的包名就是android.os,它是binder相关的jni
   REG_JNI(register_android_os_Binder),  
   ...
}
//   frameworks\base\core\jni\android_util_Binder.cpp  进入register_android_os_Binder这个方法
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) //android.os.BinderProxy中的jni方法
        return -1;
    ...
}

static int int_register_android_os_BinderProxy(JNIEnv* env)
{
    //通过反射技术进行动态注册
    ...
    return RegisterMethodsOrDie(
        env, kBinderProxyPathName,
        gBinderProxyMethods, NELEM(gBinderProxyMethods));
}

//JNINativeMethod这个结构体封装了java方法与native方法的对应关系，及方法签名
static const JNINativeMethod gBinderProxyMethods[] = {
     /* name, signature, funcPtr */
    {"pingBinder",          "()Z", (void*)android_os_BinderProxy_pingBinder},
    {"isBinderAlive",       "()Z", (void*)android_os_BinderProxy_isBinderAlive},
    {"getInterfaceDescriptor", "()Ljava/lang/String;", (void*)android_os_BinderProxy_getInterfaceDescriptor},
    {"transactNative",      "(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z", (void*)android_os_BinderProxy_transact},
    {"linkToDeath",         "(Landroid/os/IBinder$DeathRecipient;I)V", (void*)android_os_BinderProxy_linkToDeath},
    {"unlinkToDeath",       "(Landroid/os/IBinder$DeathRecipient;I)Z", (void*)android_os_BinderProxy_unlinkToDeath},
    {"getNativeFinalizer",  "()J", (void*)android_os_BinderProxy_getNativeFinalizer},
    {"getExtension",        "()Landroid/os/IBinder;", (void*)android_os_BinderProxy_getExtension},
};

//android_os_BinderProxy_transact就是我们要寻找的目标，当java层调用BinderProxy的transactNative(),就会调到这个native方法：
static jboolean android_os_BinderProxy_transact(JNIEnv* env, jobject obj,
        jint code, jobject dataObj, jobject replyObj, jint flags) // throws RemoteException
{
   ...
   //这里就是将java层的BinderProxy对象转换为native层的BpBinder对象
    IBinder* target = getBPNativeData(env, obj)->mObject.get();
   ...
   //调用BpBinder的transact()
   status_t err = target->transact(code, *data, reply, flags);
}

//进入transact()    frameworks\native\libs\binder\BpBinder.cpp
status_t BpBinder::transact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
    ...
    status_t status = IPCThreadState::self()->transact(
            mHandle, code, data, reply, flags);
    ...
}

//进入transact()  frameworks\native\libs\binder\IPCThreadState.cpp
status_t IPCThreadState::transact(int32_t handle,
                                  uint32_t code, const Parcel& data,
                                  Parcel* reply, uint32_t flags)
{
   ...
   if (reply) { 
            err = waitForResponse(reply); //即我们跨进程执行的函数时有返回值的
        } else {
            Parcel fakeReply;
            err = waitForResponse(&fakeReply);
        }
} 

status_t IPCThreadState::waitForResponse(Parcel *reply, status_t *acquireResult)
{
    ...
    while(1){
        //读写binder驱动
        if ((err=talkWithDriver()) < NO_ERROR) break;
    }
}

status_t IPCThreadState::talkWithDriver(bool doReceive)
{
    ...
    //这里的ioctl就是系统操作了，这里完成的操作就是将用户空间的数据写到内核空间中的binder驱动中
    ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr);
    ...
}

2. 将binder驱动中的数据发送到服务端

在servicemanager进程启动流程中提到，在servicemanager启动后，注册了回调方法来监听binder驱动中是否有数据写入，并开启Looper等待处理客户端发送(写入)的数据，在上一节中已经将数据写到驱动中，接下来进入监听函数：

//文件路径 frameworks\native\cmds\servicemanager\main.cpp     
class BinderCallback : public LooperCallback {
public:

    // 当binder驱动发来消息后，就可以通过次函数接收处理了
    int handleEvent(int /* fd */, int /* events */, void* /* data */) override {
        //处理消息
        IPCThreadState::self()->handlePolledCommands();
        return 1;  // Continue receiving callbacks.
    }
};

继续来看收到消息后的具体处理：

// frameworks\native\libs\binder\IPCThreadState.cpp
status_t IPCThreadState::handlePolledCommands()
{
    status_t result;
    // 当读缓存中数据未消费完时，持续循环
    do {
        result = getAndExecuteCommand();
    } while (mIn.dataPosition() < mIn.dataSize());

    // 当我们清空执行完所有的命令后，最后处理BR_DECREFS和BR_RELEASE
    processPendingDerefs();
    flushCommands();
    return result;
}

继续跟进：

status_t IPCThreadState::getAndExecuteCommand()
{
    status_t result;
    int32_t cmd;
    // 从binder驱动中读写数据并写入mIn（理论来说此时写缓存dataSize为0，也就是只读数据）
    result = talkWithDriver();
    ...
    cmd = mIn.readInt32();
    //执行读到的命令
    result = executeCommand(cmd);
    ...
}

executeCommand()主要任务就是根据binder驱动中读出的命令去执行对应的操作：

status_t IPCThreadState::executeCommand(int32_t cmd)
{
   switch ((uint32_t)cmd) {
      ...
      //以本案例，是处理这个命令
      case BR_TRANSACTION:
        {
            ...
            Parcel buffer;
            //读取数据到缓冲区
            //实例化了一个Parcel对象作为缓冲区，从binder_transaction_data中将实际数据读取出来
            buffer.ipcSetDataReference(
                reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer),
                tr.data_size,
                reinterpret_cast<const binder_size_t*>(tr.data.ptr.offsets),
                tr.offsets_size/sizeof(binder_size_t), freeBuffer, this);
            Parcel reply;
           
            //对于ServiceManager的binder节点来说，是没有ptr的
            if (tr.target.ptr) {
                // We only have a weak reference on the target object, so we must first try to
                // safely acquire a strong reference before doing anything else with it.
                // 对于其他binder服务端来说，tr.cookie为本地BBinder对象指针
                if (reinterpret_cast<RefBase::weakref_type*>(
                        tr.target.ptr)->attemptIncStrong(this)) {
                    error = reinterpret_cast<BBinder*>(tr.cookie)->transact(tr.code, buffer,
                            &reply, tr.flags);
                    reinterpret_cast<BBinder*>(tr.cookie)->decStrong(this);
                } else {
                    error = UNKNOWN_TRANSACTION;
                }

            } else { //对于serviceManager来说the_context_object就是BBinder对象，
                     //在main()中创建了ServiceManager对象并赋值给了the_context_object
                error = the_context_object->transact(tr.code, buffer, &reply, tr.flags);
            }
            ...
        }
        break;
 
   }


}

但我们在ServiceManager中并没有找到transact()方法，它定义在ServiceManager的父类BnServiceManager的父类Binder(Binder.cppframeworks\native\libs\binder\Binder.cpp)中:

status_t BBinder::transact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
    data.setDataPosition(0);

    status_t err = NO_ERROR;
    switch (code) {
        ...
        //进到这里
        default:
            err = onTransact(code, data, reply, flags);
            break;
    }
    ...
    return err;
}

而在它的子类中重写了onTransact(），来到BnServiceManager，但这个类不在AOSP中，而是通过

（frameworks\native\libs\binder\aidl\android\os\IserviceManager.aidl）生成的：

::android::status_t BnServiceManager::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) {
  ::android::status_t _aidl_ret_status = ::android::OK;
  switch (_aidl_code) {
      case ::android::IBinder::FIRST_CALL_TRANSACTION + 1 /* checkService */:
  {
    ...
    // 这里调用的是子类（即实现类 ServceManager）的checkService(0
    ::android::binder::Status _aidl_status(checkService(in_name, &_aidl_return));
    ...
  }
  break;
  }
}

来到frameworks\native\cmds\servicemanager\ServiceManager.cpp

Status ServiceManager::getService(const std::string& name, sp<IBinder>* outBinder) {
    *outBinder = tryGetService(name, true);
    // returns ok regardless of result for legacy reasons
    return Status::ok();
}

sp<IBinder> ServiceManager::tryGetService(const std::string& name, bool startIfNotFound) {
    auto ctx = mAccess->getCallingContext();

    sp<IBinder> out;
    Service* service = nullptr;
    //在android系统初始化的时候，所有的系统服务启动后都会以键值对的方式注册（保存）到ServiceManager中的mNameToService集合中
    //这里的name是我们从java层传递下来的Context.ACTIVITY_SERVICE = “activity”，他对应的是ActivityManagerService的Binder对象
    if (auto it = mNameToService.find(name); it != mNameToService.end()) {
        service = &(it->second);

        if (!service->allowIsolated) {
            uid_t appid = multiuser_get_app_id(ctx.uid);
            bool isIsolated = appid >= AID_ISOLATED_START && appid <= AID_ISOLATED_END;

            if (isIsolated) {
                return nullptr;
            }
        }
        out = service->binder;
    }

    if (!mAccess->canFind(ctx, name)) {
        return nullptr;
    }

    if (!out && startIfNotFound) {
        tryStartService(name);
    }

    if (out) {
        // Setting this guarantee each time we hand out a binder ensures that the client-checking
        // loop knows about the event even if the client immediately drops the service
        service->guaranteeClient = true;
    }

    return out;
}

到此将AMS的Binder对象返回给了客户端，有了AMS的Binder对象就可以使用AMS提供的服务(功能)了。

下图画出了跨进程通信中每层的关键流程。

七、AIDL文件生成c++文件文章来源地址https://www.toymoban.com/news/detail-407366.html

#aidl程序  设置生成的语言  aidl文件路径 aidl文件        输出路径   头文件输出路径
#sdk/build-tools
aidl.exe  --lang=cpp -I E:\src E:\src\test.aidl -o E:\dst --head_out E:\dst