Binder机制，从Java到C （1. IPC in Application Remote Service）

转载请标注：张新燕：http://www.cnblogs.com/zhangxinyan

1. Application 中的 service

我们知道Android中Service有三种类型：Local Service，Local Bounded Service，Remote Service。

Local Service：基本是提供给自已应用使用，通过startService(intent)来启动。

Local Bounded Service：也是提供给自己应用使用，通过bindService(intent)启动，然后在回调中获得service，这种service一般很少写，因为既然只提供给自己使用，又何必从回调绕个圈子呢。用第一种service就好了。

RemoteService：可以共享給更多使用者，这里就會涉及到IPC机制。在Android中，IPC机制是通过Binder来实现的。接下来就让我们开始看看Binder究竟是什么玩意吧～

2.Remote Service:

先来看看App层会遇到IPC的地方。
我们在写App时，当遇到需要在后台默默做点什么事情时，就会采用Service这个组件，当你这个Service要大公无私的向外面提供服务时，我们会采用RemoteService这个玩意。下面我们就看一下怎么样来写一个RemoteService：

1.先定義一個aidl文件：在这个文件里写上这个Service可以完成的功能接口

 package com.example.remoteservice;
     interface IRemoteService {
         void doSomething ( );
     }  

2.实现Remote Service：写一个Service组件，在这个组件里，实现Stub（Stub是啥？后面有说）的具体功能，这些功能就对应了上面aidl文件里面定义的一些接口。
接着在回调函数onBind()中把这个实现的Stub对象返回出去。那谁会来调用这个onBind()函数呢？当然是ActivityManagerService啦，有关与ActivityManagerService的详细内容会新开一篇详细说明。下面就看代码吧：

 public class RemoteService extends Service {
         @Override
         public IBinder onBind(Intent intent) {
            if (IRemoteService.class.getName().equals(intent.getAction())) {
                return mRemoteBinder;  //把一个Binder对象返回出去。其实是返回到AMS里面了。AMS：ActivityManagerService。
            }
             return null;
         }
         private final IRemoteService.Stub mRemoteBinder =new IRemoteService.Stub() {//实现Stub对象要求的方法，即AIDL的实现。
            public void dosomething() {
                blablabla;
            }
         };
     }

3.访问Remote Service：接着就是在Activity里面启动和调用Service的功能了，怎么调用呢？看代码：

 public class Helloworld extends Activity
 {
     ...
     @Override
     public void onCreate(Bundle savedInstanceState)
     {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        bindService(new Intent(IRemoteService.class.getName()),mRemoteConnection,
                     Context.BIND_AUTO_CREATE);  // 1.触发Service端回调onBind()。     （1）
        ...
        mRemoteService.getPid(); //3. 会通过Binder IPC 将操作请求发送到Service端的Stub实现。    （3）
        ...
     }  

     private ServiceConnection mRemoteConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {     （2）
            Log.i("binder_test","IBinder service : " + service.getClass());//通过Log发现，这个service是BinderProxy object，BinderProxy是什么呢？後面再說。暂时按字面理解为Binder代理对象。

            mRemoteService = IRemoteService.Stub.asInterface(service); // 2.通过asInterface,把Binder代理对象转化成接口。
        }
        public void onServiceDisconnected(ComponentName className) {
            mRemoteService = null;
        }
 };
 }   

说明：
（1）  ：在这里调用bindService，最后其实会调用到AMS（ActivityManagerService）中。AMS就会去查找当前系统中有没有已经启动过这个Service了，如果没有启动这个Service，就把它启动起来。然后会调用它的onBind()回调，获得Service的Binder对象。再经过一系列处理后，从调用者 Activity 的 （2）这个地方回调回来，把service传给它，当然其中对象会有一些变化，我们在回调的这个地方把返回的service打印了出来：

所以那个回调 onServiceConnected传进来的 IBinder service，它其实是一个BinderProxy！按照字面意思，我们称它为 Binder代理对象，先不管这个IBinder是来的，也不管BinderProxy到底是什么，先往下看，看下去你就会慢慢知道了。
这个对象返回到Activity中之后，通过asInterface进行一个转化，转化成了接口，其实是转化成了Proxy对象啦，Proxy对象实现了接口。
那这个转化得来的mRemoteService，我们以后就称之为 Service代理对象。
（3） ：这样，获得了Service的代理对象之后，就可以通过Service代理对象调用Service的功能啦。虽然Service具体的执行是在另外一个进程，但是你是感觉不到的。

3. AIDL 工具

上面说的内容似乎有点乱，那我们整理下上面的访问过程，可以看一下下面的图：

这里面的Stub对象，Stub.Proxy对象，这些对象我们上面都没有创建吧？这些类其实都是由aidl工具自动生成的。

Client中Activity，通过bindService,触发Service回调onBind()方法，把一个Binder代理对象返回给Client。

Client通过转化，转化成一个Service代理对象，Client通过这个Service代理对象，在通过底层的Binder驱动，就可以调用进Service进程。在Service进程收到请求后，会根据里面的一个参数值，找到对应的函数，执行具体的操作。

下面这个类就是用了aidl工具后，IRemoteService.aidl自动生成的对应的类：IRemoteService.java

 package com.example.remoteservice;  

     public interface IRemoteService extends android.os.IInterface { 1
         public static abstract class Stub extends android.os.Binder implements
                com.example.remoteservice.IRemoteService {//继承Binder，并且实现了IRemoteService接口
              ...
            public static com.example.remoteservice.IRemoteService asInterface(android.os.IBinder obj) {//根据传进來的IBinder对象创建一个Service 代理對象給客戶端。
                ...
                android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);
                if (((iin != null) && (iin instanceof com.example.remoteservice.IRemoteService))) {
                     return((com.example.remoteservice.IRemoteService) iin);
                }
                return new com.example.remoteservice.IRemoteService.Stub.Proxy(obj);  //看，返回的是Proxy这个对象。就是Service代理对象。
            }  

            public android.os.IBinder asBinder() {
                return this;
            }  

            @Override
            public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply,
                     int flags)throwsandroid.os.RemoteException { //把IPC消息取出来解析，找到具体执行方法。
                switch (code) {  //根据code值，找到方法。
                     case INTERFACE_TRANSACTION: {
                     }
                     case TRANSACTION_doSomething: {
                     }
                }
                return super.onTransact(code, data, reply, flags);
            }  

            private static class Proxy implements com.example.remoteservice.IRemoteService {//实现了IRemoteService接口
                private android.os.IBinder mRemote; //实际上是BinderProxy对象
               ...
                public int doSomething() throws android.os.RemoteException {
                      ...
                         mRemote.transact(Stub.TRANSACTION_doSomething,_data, _reply, 0);//通过BinderProxy將命令发送出去。
                     ….
            }
             static final int TRANSACTION_doSomething = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);   //这玩意就是用来区别方法的code。
         }  

         public void doSomething() throwsandroid.os.RemoteException;
     }  

这里面呢，会涉及到几个类，Proxy啦，Binder啦等等，他们的关系图可以在下图中看出：

那Stub和Proxy都实现了了IRemoteService。但是呢Proxy只是把参数包装一下，通过mRemote发送出去。

Stub就是真正实现的地方了，不过这边实现的代码其实是写在Service里的，就是那个mRemoteBinder。

Proxy类是Stub的一个子类。Proxy里面的mRemote就是BinderProxy，通过它就可以把请求发送出去，然后再通过底层Binder的一些操作，最后走到Service进程里去执行一些操作。

那来总结一下吧，上面这個过程可以概括的说是：

1.Activity通过AMS的bindService（String name），让AMS做一些查找操作，然后AMS把一個service的Binder代理对象返回给Activity。
2.Activity通过一個转换，创建一個service代理对象Proxy，其是在Proxy里面，还是利用Binder代理对象向service发送命令。

下一篇会将一下AMS里面的IPC机制：

Binder机制，从Java到C （2. IPC in System Service ：AMS）