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