android aidl是如何通过binder通讯的 源码分析

1 阅读5分钟

客户端

这是一个bindService并getId的例子

public class MainActivity extends AppCompatActivity {


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


        bindService(new Intent(getBaseContext(), MyService.class), new ServiceConnection() {
            @Override
            public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
                IMyService  myService = IMyService.Stub.asInterface(iBinder);
                try {
                    Log.i("fn123","id = " + myService.getId());
                } catch (RemoteException e) {
                    e.printStackTrace();
                }

            }

            @Override
            public void onServiceDisconnected(ComponentName componentName) {

            }
        }, Context.BIND_AUTO_CREATE);
    }

}

由于myService实际是客户端代理,持远程Binder引用。getId实际调用到了

@Override public void setId(int id) throws android.os.RemoteException
{
    //...
  try {
    _data.writeInterfaceToken(DESCRIPTOR);
    _data.writeInt(id);
    boolean _status = mRemote.transact(Stub.TRANSACTION_setId, _data, _reply, 0);
    _reply.readException();
  }
    //...
}

transact 方法调用到native

Binder.java

    public boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
        //...
        }
        try {
            return transactNative(code, data, reply, flags);
        } finally {
            if (tracingEnabled) {
                Trace.traceEnd(Trace.TRACE_TAG_ALWAYS);
            }
        }
    }
android_util_Binder.cpp

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

    IBinder* target = (IBinder*)
        env->GetLongField(obj, gBinderProxyOffsets.mObject);
   
        //...

    //printf("Transact from Java code to %p sending: ", target); data->print();
    status_t err = target->transact(code, *data, reply, flags);
        //...
}

这里通过获取java的mbject来进行transact,而因为mbject存储是c++层面的BpBinder对象地址,所以

BpBinder.cpp


status_t BpBinder::transact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
    // Once a binder has died, it will never come back to life.
    if (mAlive) {
        status_t status = IPCThreadState::self()->transact(
            mHandle, code, data, reply, flags);
        if (status == DEAD_OBJECT) mAlive = 0;
        return status;
    }

    return DEAD_OBJECT;
}

之后调用

IPCThreadState.cpp

status_t IPCThreadState.cpp::transact(int32_t handle,
                                  uint32_t code, const Parcel& data,
                                  Parcel* reply, uint32_t flags)
{
        //...
    if (err == NO_ERROR) {
        err = writeTransactionData(BC_TRANSACTION, flags, handle, code, data, NULL);
    }

    if ((flags & TF_ONE_WAY) == 0) {
        if (reply) {
            err = waitForResponse(reply);
        } else {
            Parcel fakeReply;
            err = waitForResponse(&fakeReply);
        }
    } else {
        err = waitForResponse(NULL, NULL);
    }

    return err;
}

writeTransactionData主要是把数据组成binder_transaction_data的结构体,然后传给binder驱动

status_t IPCThreadState::writeTransactionData主要是把数据组成(int32_t cmd, uint32_t binderFlags,
    int32_t handle, uint32_t code, const Parcel& data, status_t* statusBuffer)
{
    binder_transaction_data tr;

    tr.target.ptr = 0; /* Don't pass uninitialized stack data to a remote process */
    tr.target.handle = handle;
    tr.code = code;
    tr.flags = binderFlags;
    tr.cookie = 0;
    tr.sender_pid = 0;
    tr.sender_euid = 0;

    const status_t err = data.errorCheck();
    if (err == NO_ERROR) {
        tr.data_size = data.ipcDataSize();
        tr.data.ptr.buffer = data.ipcData();
        tr.offsets_size = data.ipcObjectsCount()*sizeof(binder_size_t);
        tr.data.ptr.offsets = data.ipcObjects();
    } else if (statusBuffer) {
        tr.flags |= TF_STATUS_CODE;
        *statusBuffer = err;
        tr.data_size = sizeof(status_t);
        tr.data.ptr.buffer = reinterpret_cast<uintptr_t>(statusBuffer);
        tr.offsets_size = 0;
        tr.data.ptr.offsets = 0;
    } else {
        return (mLastError = err);
    }

    mOut.writeInt32(cmd);
    mOut.write(&tr, sizeof(tr));

    return NO_ERROR;
}

waitForResponse从binder驱动获取消息并返回给客户端

status_t IPCThreadState::waitForResponse(Parcel *reply, status_t *acquireResult)
{
    uint32_t cmd;
    int32_t err;

    while (1) {
        if ((err=talkWithDriver()) < NO_ERROR) break;
        if (mIn.dataAvail() == 0) continue;

        cmd = (uint32_t)mIn.readInt32();
        switch (cmd) {
        case BR_REPLY:
            {
                binder_transaction_data tr;
                err = mIn.read(&tr, sizeof(tr));
                if (err != NO_ERROR) goto finish;
                }
        //...
}

服务器

服务器又是如何一步步给到客户端的呢?

public class MyService extends Service {


    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return bind;
    }

    final private IMyService.Stub bind = new IMyService.Stub() {
        @Override
        public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

        }

        @Override
        public void setId(int id) throws RemoteException {

        }


        @Override
        public int getId() throws RemoteException {
            Log.i("fn123","getId",new Exception());
            return 1;
        }
    };

}

这里添加堆栈日志,日志如下

11-03 16:35:07.197  2395  2409 I fn123   : getId
11-03 16:35:07.197  2395  2409 I fn123   : java.lang.Exception
11-03 16:35:07.197  2395  2409 I fn123   : 	at com.example.myapplication.MyService$1.getId(MyService.java:35)
11-03 16:35:07.197  2395  2409 I fn123   : 	at com.example.myapplication.IMyService$Stub.onTransact(IMyService.java:101)
11-03 16:35:07.197  2395  2409 I fn123   : 	at android.os.Binder.execTransact(Binder.java:698)

原来是execTransact,调用到类Stub的onTransac方法,看下execTransact

Binder.java

    // Entry point from android_util_Binder.cpp's onTransact
    private boolean execTransact(int code, long dataObj, long replyObj,
        int flags) {
        //...
        try {
            if (tracingEnabled) {
                Trace.traceBegin(Trace.TRACE_TAG_ALWAYS, getClass().getName() + ":" + code);
            }
            res = onTransact(code, data, reply, flags);
        } catch (RemoteException|RuntimeException e) {
            if (LOG_RUNTIME_EXCEPTION) {
                Log.w(TAG, "Caught a RuntimeException from the binder stub implementation.", e);
            }
        //...

        return res;
    }
}

这里注释写的很清楚是android_util_Binder.cpp的onTransact调过来的

添加堆栈日志我们可以发现

11-03 16:35:06.587  2395  2409 D fn123   : #00 pc 0000000000127777  /system/lib64/libandroid_runtime.so (JavaBBinder::onTransact(unsigned int, android::Parcel const&, android::Parcel*, unsigned int)+183)
11-03 16:35:06.587  2395  2409 D fn123   : #01 pc 0000000000059c1e  /system/lib64/libbinder.so (android::BBinder::transact(unsigned int, android::Parcel const&, android::Parcel*, unsigned int)+94)
11-03 16:35:06.587  2395  2409 D fn123   : #02 pc 000000000006484c  /system/lib64/libbinder.so (android::IPCThreadState::executeCommand(int)+556)
11-03 16:35:06.587  2395  2409 D fn123   : #03 pc 000000000006456c  /system/lib64/libbinder.so (android::IPCThreadState::getAndExecuteCommand()+156)
11-03 16:35:06.587  2395  2409 D fn123   : #04 pc 0000000000064bef  /system/lib64/libbinder.so (android::IPCThreadState::joinThreadPool(bool)+63)
11-03 16:35:06.587  2395  2409 D fn123   : #05 pc 000000000008ace7  /system/lib64/libbinder.so (android::PoolThread::threadLoop()+23)
11-03 16:35:06.587  2395  2409 D fn123   : #06 pc 000000000001187a  /system/lib64/libutils.so (android::Thread::_threadLoop(void*)+314)
11-03 16:35:06.587  2395  2409 D fn123   : #07 pc 00000000000b8e63  /system/lib64/libandroid_runtime.so (android::AndroidRuntime::javaThreadShell(void*)+131)
11-03 16:35:06.587  2395  2409 D fn123   : #08 pc 0000000000079f3b  /system/lib64/libc.so (__pthread_start(void*)+27)
11-03 16:35:06.587  2395  2409 D fn123   : #09 pc 0000000000028c8d  /system/lib64/libc.so (__start_thread+61)
11-03 16:35:06.587  2395  2409 D fn123   : #10 pc 0000000000027515  /system/lib64/libc.so (__bionic_clone+53)

joinThreadPool这个方法就代表会一直不断来读取驱动发过来数据

IPCThreadState.cpp

void IPCThreadState::joinThreadPool(bool isMain)
{
  do {
  //..

        result = getAndExecuteCommand();
  //..
        }
    } while (result != -ECONNREFUSED && result != -EBADF);
}
status_t IPCThreadState::getAndExecuteCommand()
{
   
    status_t result;
    int32_t cmd;
    result = talkWithDriver();
    if (result >= NO_ERROR) {
        size_t IN = mIn.dataAvail();
        if (IN < sizeof(int32_t)) return result;
        cmd = mIn.readInt32();
    }
         //..
        result = executeCommand(cmd);
	//..


    return result;
}
status_t IPCThreadState::executeCommand(int32_t cmd)
{
    //..
    switch ((uint32_t)cmd) {
    case BR_TRANSACTION:
        {
            binder_transaction_data tr;
            result = mIn.read(&tr, sizeof(tr));
            
            if (tr.target.ptr) {
                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 {
                error = the_context_object->transact(tr.code, buffer, &reply, tr.flags);
            }
            if ((tr.flags & TF_ONE_WAY) == 0) {
                sendReply(reply, 0);
            }
    //..

        }
        break;
    //..
    return result;
}
status_t BBinder::transact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
       //..
    switch (code) {
          //..
        default:
            err = onTransact(code, data, reply, flags);
            break;
    }
   //..
    return err;
}

这个最后由onTransact调用到java层获取到服务端数据

virtual status_t onTransact调用到java层获取到服务端数据(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags = 0)
{
    //...
    jboolean res = env->CallBooleanMethod(mObject, gBinderOffsets.mExecTransact,
        code, reinterpret_cast<jlong>(&data), reinterpret_cast<jlong>(reply), flags);
    //...
    return res != JNI_FALSE ? NO_ERROR : UNKNOWN_TRANSACTION;
}