客户端
这是一个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;
}