Android Binder服务——java实现

转换： 
# dx --dex --output=Hello.jar Hello.class 
执行： 
# dalvikvm -cp ./Hello.jar Hello    //-cp: 指定class path 
 
另一种方法是使用app_process去执行： 
# CLASSPATH=./Hello.jar app_process    ./ Hello //可以-h查看帮助,‘./’是指定父目录 
 
app_process的用法： 
# app_process [java-options] cmd-dir start-class-name [options] 
 
cmd-dir: 指定要读取文件时基于此目录。 
CLASSPATH：指定需要的类从哪里找。 
 
# dx --dex --output=Hello.jar .  //将当前目录下的所有class都打包成Hello.jar

参考frameworks/base/cmds/am/Android.mk 
LOCAL_PATH:= $(call my-dir) 
include $(CLEAR_VARS) 
LOCAL_SRC_FILES := $(call all-subdir-java-files) 
LOCAL_MODULE := your_jar_file_name 
include $(BUILD_JAVA_LIBRARY)

服务层 
-------------- 
RPC层 
------------- 
IPC层（最核心的类是IPCThreadState） 
-------------

1.Client端的实现 
包括TestServer向SM发送addService请求、TestClient向SM发送getService请求、TestClient向TestServer发送调用say_hello()的请求。 
 
(1)addService/getService请求 
 
ServiceManager.addService("hello", new HelloService());    //TestServer.java 
    ServiceManagerProxy(obj).addService(name, service, false); //ServiceManagerNative.java 
        mRemote.transact(ADD_SERVICE_TRANSACTION, data, reply, 0); //ServiceManagerNative.java 调用它发送数据 
     
 
IBinder binder = ServiceManager.getService("hello"); //TestClient.java 
    ServiceManagerProxy(obj).getService(name); //ServiceManagerNative.java 
        mRemote.transact(GET_SERVICE_TRANSACTION, data, reply, 0); //ServiceManagerNative.java 调用它发送数据 
 
 
(2)Client使用sayhello()/sayhello_to() 
 
IHelloService svr = IHelloService.Stub.asInterface(binder); //TestClient.java  
    svr.sayhello(); //TestClient.java  
        IHelloService.Stub.Proxy(obj).sayhello(); //IHelloService.java 
 
 
Client端和Service端最终都是调用IBinder mRemote来发送数据，Client端和Service端就统一起来了。 
 
调用mRemote.transact(Stub.TRANSACTION_sayhello, _data, _reply, 0);来发送数据 
数据传输3要素： 
源：调用mRemote.transact的进程 
目的：mRemote 
数据本身：参数 
 
Binder中的目的是使用handle表示的，对于addService()/getService()这个mRemote中肯定有handle=0这个成员。 
 
mRemote是一个java BinderProxy对象(但是看代码是IBinder对象)，它的 
mObject指向一个C++的BpBinder对象，这个BpBInder的mHandle=0表示要发给SM进程。 
 
 
对于Client使用sayhello()/sayhello_to()，mRemote是一个java BinderProxy对象(但是看代码是IBinder对象)，它的 
mObject指向一个C++的BpBinder对象，这个BpBInder的mHandle=1(来自getService("hello"))表示要发给HelloService进程。 
 
 
1.ServiceManagerProxy中mRemote的构造 (用于addService/getService) 
猜测：使用0直接构造出一个java BinderProxy对象 
ServiceManager.addService("hello", new HelloService());    或 ServiceManager.getService("hello"); //TestServer.java 
     getIServiceManager().addService(name, service, false); //ServiceManager.java 
 
a. getIServiceManager() 
    ServiceManagerNative.asInterface(BinderInternal.getContextObject()); 
 
a1. 分析BinderInternal.getContextObject()    //BinderInternal.java，getContextObject()是一个native函数 
    //这个函数最终得到一个java BinderProxy对象, 其中mObject指向new BpBinder(0);。 
        android_os_BinderInternal_getContextObject //android_util_Binder.cpp 
            sp<IBinder> b = ProcessState::self()->getContextObject(NULL); //android_util_Binder.cpp 
                return getStrongProxyForHandle(0); //ProcessState.cpp，直接指定的是handle=0，是SM 
                    b = new BpBinder(0); //BpBinder.cpp  BpBinder.mHandle=0 
            return javaObjectForIBinder(env, b); //android_util_Binder.cpp  b = new BpBinder(0), mHandle = 0 
                object = env->NewObject(gBinderProxyOffsets.mClass, gBinderProxyOffsets.mConstructor); //android_util_Binder.cpp 
                //JNI代码中使用NewObject()来创建Java的BinderProxy对象。 
                    const char* const kBinderProxyPathName = "android/os/BinderProxy"; 
                    clazz = env->FindClass(kBinderProxyPathName); 
                    gBinderProxyOffsets.mConstructor = env->GetMethodID(clazz, "<init>", "()V"); //调用的是BinderProxy的构造函数。 
 
 
a2.分析ServiceManagerNative.asInterface 
    new ServiceManagerProxy(obj); // obj = BinderProxy对象 
        mRemote = obj = BinderProxy对象, 其中mObject指向new BpBinder(0), 0表示是SM。 
 
所以getService/setService使用的mRemote已经构造出来了。 
 
 
 
2.Hello服务里面的mRemote如何构造的 
a. IBinder binder = ServiceManager.getService("hello"); 
   //猜测: 它的返回值就是一个java BinderProxy对象, 其中的mObject=new BpBinder(handle)  
        new ServiceManagerProxy().getService("hello"); //ServiceManagerNative.java 
        //构造数据通过mRemote发送出去，从返回的结果中得到 
        IBinder binder = reply.readStrongBinder(); //ServiceManagerNative.java 
            return nativeReadStrongBinder(mNativePtr); //Parcel.java 它标注为native,是一个JNI函数 
                // 把java Parce对象转换为c++ Parcel对象 
                // client程序向sevice_manager发出getService请求， 
                // 得到一个回复reply, 它里面含有flat_binder_object 
                // 它被封装成一个c++ Parcel对象 
                Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 
                //它应该会把上面的flat_binder_object转换成一个BpBinder对象。 
                //它会创建一个java BinderProxy对象, 其中的mObject=new BpBinder(handle)对象 
                return javaObjectForIBinder(env, parcel->readStrongBinder()); //android_os_Parcel.cpp 
                 
 
a1. parcel->readStrongBinder()返回一个 new BpBinder(handle)对象，其中handle是HelloService的handle 
        unflatten_binder(ProcessState::self(), *this, &val); //Parcel.cpp 
            finish_unflatten_binder //Parcel.cpp 
                b = new BpBinder(handle);  
                 
b. IHelloService svr = IHelloService.Stub.asInterface(binder); //TestClient.java  
    return new IHelloService.Stub.Proxy(obj); //IHelloService.java 
        mRemote = obj; //那么，a中返回的就是一个BinderProxy对象。 
 
 
3.现在知道了mRemote就是一个java的BinderProxy对象(定义在Binder.java中)，mRemote.transact()的实现方法如下 
 
BinderProxy.transact(int code, Parcel data, Parcel reply, int flags); //Binder.java 
    return transactNative(code, data, reply, flags); //它是一个JNI调用，对应android_os_BinderProxy_transact 
        android_os_BinderProxy_transact //android_util_Binder.cpp 
            //取出data和reply, 把java对象转换为C++对象。 
            Parcel* data = parcelForJavaObject(env, dataObj); 
            Parcel* reply = parcelForJavaObject(env, replyObj); 
            //从java BinderProxy对象中把mObject取出, 它就是一个BpBinder对象 
            IBinder* target = (IBinder*)env->GetLongField(obj, gBinderProxyOffsets.mObject); 
            //然后调用BpBinder的transact 
            status_t err = target->transact(code, *data, reply, flags); 
 
4."怎么发"结论如下 
对于getService/setService,会得到一个ServiceManagerProxy代理类，对应Hello服务也会得到一个 
代理类IHelloService.Stub.Proxy。这些代理类中都有一个mRemote成员, 
它是一个java的BinderProxy对象，它的mObject成员指向一个C++的BpBinder对象， 
BpBinder中有一个mHandle(对于addService/getService它是0，对于Hello服务，它 
来自getService的结果)。 
 
发送数据时，调用mRemote.transact()，它会从mObject中取出BpBinder对象，调用它的 
transact函数，从而实现了Java实现的RPC对C++实现的IPC的调用。

1. Server怎么读到数据 
 
看HelloService.java源码，它addService()之后就去睡眠去了，那是谁在读取处理数据呢，是使用app_process创建的两个binder线程binder_1和binder_2做的， 
源码： 
app_process: frameworks\base\cmds\app_process\app_main.cpp 
 
app_process来启动server进程,它会先创建子线程: 
AppRuntime::onStarted() 
    proc->startThreadPool(); 
        spawnPooledThread(true); 
            sp<Thread> t = new PoolThread(isMain); 
            t->run(name.string()); 
                //它会创建子线程, 并执行threadLoop 
                IPCThreadState::self()->joinThreadPool(mIsMain); 
                { 
                    do { 
                        result = getAndExecuteCommand(); 
                            result = talkWithDriver(); 
                            result = executeCommand(cmd); 
                                对于BR_TRANSACTION数据, 
                                sp<BBinder> b((BBinder*)tr.cookie); //cookie来区分是哪个服务，一个进程可能注册了多个Service。 
                                error = b->transact(tr.code, buffer, &reply, tr.flags); 
                    } while(...) 
                } 
 
 
 
 
 
2. server读到数据后怎么调用服务PRC层的onTransact函数 
 
a. 在addService时设置.ptr/.cookie 
ServiceManager.addService("hello", new HelloService()); 
分析： 
a.1 new HelloService()是JAVA对象 
a.2 处理数据时把.cookie转换成BBinder对象, 它是c++对象 
所以: addService中肯定会把JAVA对象转换成一个BBinder派生类对象，存在.cookie里 
 
结论: 
a.1 addService会通过JNI调用c++函数: 
        创建一个BBinder派生类JavaBBinder对象, 
            它的.mObject指向JAVA对象: new HelloService() 
            它含有onTransact函数 
        把这个对象存入.cookie(最终存入binder驱动中该服务对应的binder_node.cookie) 
 
a.2 server进程从驱动中读到数据，里面含有.cookie 
    把它转换为BBinder对象， 
    调用它的transact函数  
    它会调用到派生类JavaBBinder中定义的onTransact函数 
 
a.3 JavaBBinder中定义的onTransact函数(c++) 
    它通过JNI调用java Binder的execTransact方法， 
    然后调用Binder派生类IHelloService.Stub中定义的onTransact函数(JAVA) 
 
a.4 IHelloService.Stub中定义的onTransact函数(JAVA): 
        分析数据 
        调用sayhello/sayhello_to 
 
源码阅读： 
a.1 ServiceManager.addService("hello", new HelloService()); 
    ServiceManagerProxy.addService: 
        // Parcel.java 
        data.writeStrongBinder(service); 
            nativeWriteStrongBinder(mNativePtr, val); // val = service = new HelloService() 
            它是一个JNI调用，对应android_os_Parcel_writeStrongBinder(c++实现) 
 
a.2 android_os_Parcel_writeStrongBinder(c++) 
    它会构造一个JavaBBinder对象(c++)，.mObject=new HelloService() JAVA对象 
    然后让.cookie=JavaBBinder对象(c++) 
     
    //把Java Parcel转换为c++ Parcel 
    Parcel* parcel = reinterpret_cast<Parcel*>(nativePtr); 
     
    //.cookie = ibinderForJavaObject(env, object)得到一个JavaBBinder对象 
    parcel->writeStrongBinder(ibinderForJavaObject(env, object)) 
 
a.3 ibinderForJavaObject(env, object) //object = new HelloService()  
    把一个Java对象(new HelloService())转换为c++ IBinder对象 
     
    JavaBBinderHolder* jbh = (JavaBBinderHolder*)env->GetLongField(obj, gBinderOffsets.mObject); 
    return jbh != NULL ? jbh->get(env, obj) : NULL; 
         b = new JavaBBinder(env, obj); // obj = new HelloService()  
            mObject = new HelloService()  
 
 
a.4 从驱动中得到.cookie, 它是一个JavaBBinder对象 
    调用它的transact函数，导致JavaBBinder对象的onTransact被调用 
     
    JavaBBinder::onTransact (调用java里的某个函数) 
     
        // mObject指向 HelloService对象 
        // gBinderOffsets.mExecTransact指向: java Binder类中的execTransact方法 
        // 调用HelloService(派生自Binder)对象中的execTransact方法 
        jboolean res = env->CallBooleanMethod(mObject, gBinderOffsets.mExecTransact, 
            code, reinterpret_cast<jlong>(&data), reinterpret_cast<jlong>(reply), flags); 
 
a.5 java Binder execTransact:   
        res = onTransact(code, data, reply, flags); 
            调用HelloService中的onTransact方法(来自IHelloService.Stube) 
                分辨数据 
                调用sayhello/sayhello_to