Android 手写Binder 教你理解android中的进程间通信

关于Binder，我就不解释的太多了，网上一搜资料一堆，但是估计还是很多人理解的有困难。今天就教你如何从 app层面来理解好Binder。

其实就从我们普通app开发者的角度来看，仅仅对于android应用层的话，Binder就是客户端和服务端进行通信的媒介。

AIDL就是我们理解Binder 最好的事例。

我们都知道 我们写好aidl 文件以后，开发工具 会自动帮我们生成好代码。实际上 我们最终apk里面 是只有这些代码的，我们写的aidl文件

是不会被打包进去的，也就是说aidl文件 实际上 就是我们用来 生成 实际binder代码用的。所以 我们只要能够分析好，ide自动帮我们生成的

代码，就可以自己手写binder，从而在app层面上真正理解binder的用法和含义 以及原理。

首先我先来定义一个实体类：Person.java

 package com.example.administrator.writebindercodeexample;

 import android.os.Parcel;
 import android.os.Parcelable;

 /**
  * Created by Administrator on 2016/1/27.
  */
 public class Person implements Parcelable {

     private String name;

     public void setName(String name) {
         this.name = name;
     }

     public void setGender(int gender) {
         this.gender = gender;
     }

     public int getGender() {
         return gender;
     }

     public String getName() {
         return name;
     }

     private int gender;

     @Override
     public int describeContents() {
         return 0;
     }

     @Override
     public void writeToParcel(Parcel dest, int flags) {
         dest.writeString(this.name);
         dest.writeInt(this.gender);
     }

     public Person() {
     }

     protected Person(Parcel in) {
         this.name = in.readString();
         this.gender = in.readInt();
     }

     public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() {
         public Person createFromParcel(Parcel source) {
             return new Person(source);
         }

         public Person[] newArray(int size) {
             return new Person[size];
         }
     };
 }

注意看  我们这个person 类 是实现了android自带的序列化接口的，所以 如果你要在aidl里使用这个类，那你必须要额外在aidl里生命下 这个类。

 // Person.aidl.aidl
 package com.example.administrator.writebindercodeexample;

 // Declare any non-default types here with import statements
 parcelable Person;

 // IPersonManager.aidl
 package com.example.administrator.writebindercodeexample;

 // Declare any non-default types here with import statements
 import com.example.administrator.writebindercodeexample.Person;
 interface IPersonManager {
     List<Person> getPersonList();
     //关于这个参数in 其实你不加也是可以编译通过的，这里我就先加一下 具体参数的意义 以后会说
     void addPerson(in Person person);
 }

好，然后给你们看一下 文件结构：

好 这里就是一个典型的 应用aidl 技术的 一个例子，我们现在 让studio 编译这个project，然后看看生成的binder代码。 把这份binder代码 分析好了，我们以后就可以不借助ide 来自己手写binder了。

我们来看看 生成的代码在哪里：

最后我们来看一下 这个生成的代码 是啥样的：

 /*
  * This file is auto-generated.  DO NOT MODIFY.
  * Original file: C:\\Users\\Administrator\\WriteBinderCodeExample\\app\\src\\main\\aidl\\com\\example\\administrator\\writebindercodeexample\\IPersonManager.aidl
  */
 package com.example.administrator.writebindercodeexample;
 public interface IPersonManager extends android.os.IInterface
 {
 /** Local-side IPC implementation stub class. */
 public static abstract class Stub extends android.os.Binder implements com.example.administrator.writebindercodeexample.IPersonManager
 {
 private static final java.lang.String DESCRIPTOR = "com.example.administrator.writebindercodeexample.IPersonManager";
 /** Construct the stub at attach it to the interface. */
 public Stub()
 {
 this.attachInterface(this, DESCRIPTOR);
 }
 /**
  * Cast an IBinder object into an com.example.administrator.writebindercodeexample.IPersonManager interface,
  * generating a proxy if needed.
  */
 public static com.example.administrator.writebindercodeexample.IPersonManager asInterface(android.os.IBinder obj)
 {
 if ((obj==null)) {
 return null;
 }
 android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
 if (((iin!=null)&&(iin instanceof com.example.administrator.writebindercodeexample.IPersonManager))) {
 return ((com.example.administrator.writebindercodeexample.IPersonManager)iin);
 }
 return new com.example.administrator.writebindercodeexample.IPersonManager.Stub.Proxy(obj);
 }
 @Override public android.os.IBinder asBinder()
 {
 return this;
 }
 @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
 {
 switch (code)
 {
 case INTERFACE_TRANSACTION:
 {
 reply.writeString(DESCRIPTOR);
 return true;
 }
 case TRANSACTION_getPersonList:
 {
 data.enforceInterface(DESCRIPTOR);
 java.util.List<com.example.administrator.writebindercodeexample.Person> _result = this.getPersonList();
 reply.writeNoException();
 reply.writeTypedList(_result);
 return true;
 }
 case TRANSACTION_addPerson:
 {
 data.enforceInterface(DESCRIPTOR);
 com.example.administrator.writebindercodeexample.Person _arg0;
 if ((0!=data.readInt())) {
 _arg0 = com.example.administrator.writebindercodeexample.Person.CREATOR.createFromParcel(data);
 }
 else {
 _arg0 = null;
 }
 this.addPerson(_arg0);
 reply.writeNoException();
 return true;
 }
 }
 return super.onTransact(code, data, reply, flags);
 }
 private static class Proxy implements com.example.administrator.writebindercodeexample.IPersonManager
 {
 private android.os.IBinder mRemote;
 Proxy(android.os.IBinder remote)
 {
 mRemote = remote;
 }
 @Override public android.os.IBinder asBinder()
 {
 return mRemote;
 }
 public java.lang.String getInterfaceDescriptor()
 {
 return DESCRIPTOR;
 }
 @Override public java.util.List<com.example.administrator.writebindercodeexample.Person> getPersonList() throws android.os.RemoteException
 {
 android.os.Parcel _data = android.os.Parcel.obtain();
 android.os.Parcel _reply = android.os.Parcel.obtain();
 java.util.List<com.example.administrator.writebindercodeexample.Person> _result;
 try {
 _data.writeInterfaceToken(DESCRIPTOR);
 mRemote.transact(Stub.TRANSACTION_getPersonList, _data, _reply, 0);
 _reply.readException();
 _result = _reply.createTypedArrayList(com.example.administrator.writebindercodeexample.Person.CREATOR);
 }
 finally {
 _reply.recycle();
 _data.recycle();
 }
 return _result;
 }
 //关于这个参数in 其实你不加也是可以编译通过的，这里我就先加一下 具体参数的意义 以后会说

 @Override public void addPerson(com.example.administrator.writebindercodeexample.Person person) throws android.os.RemoteException
 {
 android.os.Parcel _data = android.os.Parcel.obtain();
 android.os.Parcel _reply = android.os.Parcel.obtain();
 try {
 _data.writeInterfaceToken(DESCRIPTOR);
 if ((person!=null)) {
 _data.writeInt(1);
 person.writeToParcel(_data, 0);
 }
 else {
 _data.writeInt(0);
 }
 mRemote.transact(Stub.TRANSACTION_addPerson, _data, _reply, 0);
 _reply.readException();
 }
 finally {
 _reply.recycle();
 _data.recycle();
 }
 }
 }
 static final int TRANSACTION_getPersonList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
 static final int TRANSACTION_addPerson = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
 }
 public java.util.List<com.example.administrator.writebindercodeexample.Person> getPersonList() throws android.os.RemoteException;
 //关于这个参数in 其实你不加也是可以编译通过的，这里我就先加一下 具体参数的意义 以后会说

 public void addPerson(com.example.administrator.writebindercodeexample.Person person) throws android.os.RemoteException;
 }

看上去呢，杂乱无章， 但其实也就是100多行，所以 我调整了一下 这个代码的顺序 ，你们可以看的更清楚，同时也增加了注释：

 package com.example.administrator.aidlmessagetest;

 //为了让大家看的更清楚 我把生成的binder代码 给拷贝到另外一个工程下面了，并且用ide 给他format
 //所以包名和我们一开始前面的代码都不一样，大家理解意思就行。

 //从前面几行就能看出来 生成的代码是一个 interface ，只不过这个interface是 android.os.IInterface 的子类！
 public interface IPersonManager extends android.os.IInterface {

     //并且这个接口里 有一个静态的抽象类Stub(注意这个名字是固定的 永远都是Stub 不会是其他)
     //并且这个Stub是Binder的子类，并且实现了IPersonManager 这个接口
     public static abstract class Stub extends android.os.Binder implements com.example.administrator.aidlmessagetest.IPersonManager {
         //这个东西就是唯一的binder标示 可以看到就是IPersonManager的全路径名
         private static final java.lang.String DESCRIPTOR = "com.example.administrator.aidlmessagetest.IPersonManager";

         /**
          * 这个就是Stub的构造方法，回顾一下 我们如果写好aidl文件以后 写的service里面 是怎么写的？
          *
          * private final IPersonManager.Stub mBinder = new IPersonManager.Stub() {}
          * 我们都是这么写的 对吧~~所以想想我们的service里面的代码 就能辅助理解 这里的代码了
          */
         public Stub() {
             this.attachInterface(this, DESCRIPTOR);
         }

         //这个方法 其实就做了一件事，如果是同一个进程，那么就返回Stub对象本身
         //如果不是同一个进程，就返回Stub.Proxy这个代理对象了
         public static com.example.administrator.aidlmessagetest.IPersonManager asInterface(android.os.IBinder obj) {
             if ((obj == null)) {
                 return null;
             }
             android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
             //如果是同1个进程，也就是说进程内通信的话 我们就返回括号内里的对象
             if (((iin != null) && (iin instanceof com.example.administrator.aidlmessagetest.IPersonManager))) {
                 return ((com.example.administrator.aidlmessagetest.IPersonManager) iin);
             }
             //如果不是同一进程，是2个进程之间相互通信，那我们就得返回这个Stub.Proxy 看上去叫Stub 代理的对象了
             return new com.example.administrator.aidlmessagetest.IPersonManager.Stub.Proxy(obj);
         }

         //返回当前对象
         @Override
         public android.os.IBinder asBinder() {
             return this;
         }

         //只有在多进程通信的时候 才会调用这个方法 ，同一个进程是不会调用的。

         //首先 我们要明白 这个方法 一般情况下 都是返回true的，也只有返回true的时候才有意义，如果返回false了 就代表这个方法执行失败，
         //所以我们通常是用这个方法来做权限认证的，其实也很好理解，既然是多进程通信，那么我们服务端的进程当然不希望谁都能过来调用
         //所以权限认证是必须的，关于权限认证的代码 以后我再讲 先略过。

         //除此之外 ，onTransact 这个方法 就是运行在Binder线程池中的，一般就是客户端发起请求，然后android底层代码把这个客户端发起的
         //请求 封装成3个参数 来调用这个onTransact方法，第一个参数code 就代表客户端想要调用服务端 方法的 标志位。
         //其实也很好理解 服务端可能有n个方法 每个方法 都有一个对应的int值来代表，这个code就是这个int值，用来标示客户端想调用的服务端的方法
         //data就是方法参数，reply就是方法返回值。都很好理解

         //其实隐藏了很重要的一点，这个方法既然是运行在binder线程池中的，所以在这个方法里面调用的服务器方法也是运行在Binder线程池中的，
         //所以我们要记得 如果你的服务端程序 有可能和多个客户端相联的话，你方法里使用的那些参数 必须要是支持异步的，否则的话
         //值就会错乱了！这点一定要记住！结论就是Binder方法 一定要是同步方法！！！！！！
         @Override
         public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
             switch (code) {
                 case INTERFACE_TRANSACTION: {
                     reply.writeString(DESCRIPTOR);
                     return true;
                 }
                 case TRANSACTION_getPersonList: {
                     data.enforceInterface(DESCRIPTOR);
                     java.util.List<com.example.administrator.aidlmessagetest.Person> _result = this.getPersonList();
                     reply.writeNoException();
                     reply.writeTypedList(_result);
                     return true;
                 }
                 case TRANSACTION_addPerson: {
                     data.enforceInterface(DESCRIPTOR);
                     com.example.administrator.aidlmessagetest.Person _arg0;
                     if ((0 != data.readInt())) {
                         _arg0 = com.example.administrator.aidlmessagetest.Person.CREATOR.createFromParcel(data);
                     } else {
                         _arg0 = null;
                     }
                     this.addPerson(_arg0);
                     reply.writeNoException();
                     return true;
                 }
             }
             return super.onTransact(code, data, reply, flags);
         }

         //注意这里的Proxy 这个类名也是不变的，从前文我们知道 只有在多进程通信的情况下  才会返回这个代理的对象
         private static class Proxy implements com.example.administrator.aidlmessagetest.IPersonManager {
             private android.os.IBinder mRemote;

             Proxy(android.os.IBinder remote) {
                 mRemote = remote;
             }

             @Override
             public android.os.IBinder asBinder() {
                 return mRemote;
             }

             public java.lang.String getInterfaceDescriptor() {
                 return DESCRIPTOR;
             }

             //这里我们一共有2个方法 一个getPersonList 一个addPerson 我们就分析一个方法就可以了
             //并且要知道 这2个方法运行在客户端！！！！！！！！！！！！！！！！
             //首先就是创建了3个对象_data 输入对象，_reply输出对象，_result返回值对象
             //然后把参数信息 写入到_data里，接着就调用了transact这个方法 来发送rpc请求，然后接着
             //当前线程挂起， 服务端的onTransace方法才被调用，调用结束以后 当前线程继续执行，直到
             //从_reply中取出rpc的返回结果 然后返回_reply的数据

             //所以这里我们就要注意了，客户端发起调用远程请求时，当前客户端的线程就会被挂起了，
             //所以如果一个远程方法 很耗时，我们客户端就一定不能在ui main线程里在发起这个rpc请求，不然就anr了。
             @Override
             public java.util.List<com.example.administrator.aidlmessagetest.Person> getPersonList() throws android.os.RemoteException {
                 android.os.Parcel _data = android.os.Parcel.obtain();
                 android.os.Parcel _reply = android.os.Parcel.obtain();
                 java.util.List<com.example.administrator.aidlmessagetest.Person> _result;
                 try {
                     _data.writeInterfaceToken(DESCRIPTOR);
                     mRemote.transact(Stub.TRANSACTION_getPersonList, _data, _reply, 0);
                     _reply.readException();
                     _result = _reply.createTypedArrayList(com.example.administrator.aidlmessagetest.Person.CREATOR);
                 } finally {
                     _reply.recycle();
                     _data.recycle();
                 }
                 return _result;
             }

             //你看自动生成binder代码的时候 连你的注释也一起拷贝过来了。。。。。是不是很有趣
             //关于这个参数in 其实你不加也是可以编译通过的，这里我就先加一下 具体参数的意义 以后会说

             @Override
             public void addPerson(com.example.administrator.aidlmessagetest.Person person) throws android.os.RemoteException {
                 android.os.Parcel _data = android.os.Parcel.obtain();
                 android.os.Parcel _reply = android.os.Parcel.obtain();
                 try {
                     _data.writeInterfaceToken(DESCRIPTOR);
                     if ((person != null)) {
                         _data.writeInt(1);
                         person.writeToParcel(_data, 0);
                     } else {
                         _data.writeInt(0);
                     }
                     mRemote.transact(Stub.TRANSACTION_addPerson, _data, _reply, 0);
                     _reply.readException();
                 } finally {
                     _reply.recycle();
                     _data.recycle();
                 }
             }
         }

         static final int TRANSACTION_getPersonList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
         static final int TRANSACTION_addPerson = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
     }

     public java.util.List<com.example.administrator.aidlmessagetest.Person> getPersonList() throws android.os.RemoteException;
 //关于这个参数in 其实你不加也是可以编译通过的，这里我就先加一下 具体参数的意义 以后会说

     public void addPerson(com.example.administrator.aidlmessagetest.Person person) throws android.os.RemoteException;
 }

到这里 相信大家 至少在应用层上面，就对Binder就一个很直观的理解了，对于进程间通信来说，具体的流程就分为如下几步：

1.Client 发起远程调用请求 也就是RPC 到Binder。同时将自己挂起，挂起的原因是要等待RPC调用结束以后返回的结果

2.Binder 收到RPC请求以后 把参数收集一下，调用transact方法，把RPC请求转发给service端。

3.service端 收到rpc请求以后 就去线程池里 找一个空闲的线程去走service端的 onTransact方法 ，实际上也就是真正在运行service端的 方法了，等方法运行结束 就把结果 写回到binder中。

4.Binder 收到返回数据以后 就唤醒原来的Client 线程，返回结果。至此，一次进程间通信 的过程就结束了

搞明白以后 我们就可以来尝试着 手下一下Binder：（前面我们aidl 帮我们生成的binder 是人，也就是person，那这次我们自己写的时候 就用狗吧，用DOG）

首先定义一个Dog.java: 实际上和person 一样的 所以这里暂时把代码折叠起来。

 package com.example.administrator.writebindercodeexample;

 import android.os.Parcel;
 import android.os.Parcelable;

 /**
  * Created by Administrator on 2016/1/27.
  */
 public class Dog implements Parcelable {

     public int getGender() {
         return gender;
     }

     public String getName() {
         return name;
     }

     public void setGender(int gender) {
         this.gender = gender;
     }

     public void setName(String name) {
         this.name = name;
     }

     private int gender;
     private String name;

     @Override
     public int describeContents() {
         return 0;
     }

     @Override
     public void writeToParcel(Parcel dest, int flags) {
         dest.writeInt(this.gender);
         dest.writeString(this.name);
     }

     public Dog() {
     }

     protected Dog(Parcel in) {
         this.gender = in.readInt();
         this.name = in.readString();
     }

     public static final Parcelable.Creator<Dog> CREATOR = new Parcelable.Creator<Dog>() {
         public Dog createFromParcel(Parcel source) {
             return new Dog(source);
         }

         public Dog[] newArray(int size) {
             return new Dog[size];
         }
     };
 }

然后写一个接口IDogManager

 package com.example.administrator.writebindercodeexample;

 import android.os.IBinder;
 import android.os.IInterface;
 import android.os.RemoteException;

 import java.util.List;

 /**
  * Created by Administrator on 2016/1/27.
  */
 public interface IDogManager extends IInterface {

     static final String DESCRIPTOR = "com.example.administrator.writebindercodeexample.IDogManager";
     static final int TRANSACTION_getDogList = IBinder.FIRST_CALL_TRANSACTION + 0;
     static final int TRANSACTION_addDog = IBinder.FIRST_CALL_TRANSACTION + 1;

     public List<Dog> getDogList() throws RemoteException;

     public void addDog(Dog dog) throws RemoteException;

 }

然后写我们的binder，注意我们的binder 我这里是写的抽象类，因为你写成实体类的话 就必须要实现IDogManger里的2个方法 ，然而为了结构清晰 我们并不准备把binder 放在service里 实现。

所以这里binder 我们还是用抽象类来做，然后在service里 实现 getDogList和addDog方法即可。

 package com.example.administrator.writebindercodeexample;

 import android.os.Binder;
 import android.os.IBinder;
 import android.os.Parcel;
 import android.os.RemoteException;

 /**
  * Created by Administrator on 2016/1/27.
  */
 public abstract class DogManagerImpl extends Binder implements IDogManager {

     public DogManagerImpl() {
         this.attachInterface(this, DESCRIPTOR);
     }

     public static com.example.administrator.writebindercodeexample.IDogManager asInterface(android.os.IBinder obj) {
         if ((obj == null)) {
             return null;
         }
         android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
         //如果是同1个进程，也就是说进程内通信的话 我们就返回括号内里的对象
         if (((iin != null) && (iin instanceof com.example.administrator.writebindercodeexample.IDogManager))) {
             return ((com.example.administrator.writebindercodeexample.IDogManager) iin);
         }
         //如果不是同一进程，是2个进程之间相互通信，那我们就得返回这个Stub.Proxy 看上去叫Stub 代理的对象了
         return new com.example.administrator.writebindercodeexample.DogManagerImpl.Proxy(obj);
     }

     @Override
     public IBinder asBinder() {
         return this;
     }

     @Override
     protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
         switch (code) {
             case INTERFACE_TRANSACTION: {
                 reply.writeString(DESCRIPTOR);
                 return true;
             }
             case TRANSACTION_getDogList: {
                 data.enforceInterface(DESCRIPTOR);
                 java.util.List<com.example.administrator.writebindercodeexample.Dog> _result = this.getDogList();
                 reply.writeNoException();
                 reply.writeTypedList(_result);
                 return true;
             }
             case TRANSACTION_addDog: {
                 data.enforceInterface(DESCRIPTOR);
                 com.example.administrator.writebindercodeexample.Dog _arg0;
                 if ((0 != data.readInt())) {
                     _arg0 = com.example.administrator.writebindercodeexample.Dog.CREATOR.createFromParcel(data);
                 } else {
                     _arg0 = null;
                 }
                 this.addDog(_arg0);
                 reply.writeNoException();
                 return true;
             }
         }
         return super.onTransact(code, data, reply, flags);
     }

     private static class Proxy extends DogManagerImpl {
         private android.os.IBinder mRemote;

         Proxy(android.os.IBinder remote) {
             mRemote = remote;
         }

         @Override
         public android.os.IBinder asBinder() {
             return mRemote;
         }

         public java.lang.String getInterfaceDescriptor() {
             return DESCRIPTOR;
         }

         @Override
         public java.util.List<com.example.administrator.writebindercodeexample.Dog> getDogList() throws android.os.RemoteException {
             android.os.Parcel _data = android.os.Parcel.obtain();
             android.os.Parcel _reply = android.os.Parcel.obtain();
             java.util.List<com.example.administrator.writebindercodeexample.Dog> _result;
             try {
                 _data.writeInterfaceToken(DESCRIPTOR);
                 mRemote.transact(DogManagerImpl.TRANSACTION_getDogList, _data, _reply, 0);
                 _reply.readException();
                 _result = _reply.createTypedArrayList(com.example.administrator.writebindercodeexample.Dog.CREATOR);
             } finally {
                 _reply.recycle();
                 _data.recycle();
             }
             return _result;
         }

         @Override
         public void addDog(com.example.administrator.writebindercodeexample.Dog dog) throws android.os.RemoteException {
             android.os.Parcel _data = android.os.Parcel.obtain();
             android.os.Parcel _reply = android.os.Parcel.obtain();
             try {
                 _data.writeInterfaceToken(DESCRIPTOR);
                 if ((dog != null)) {
                     _data.writeInt(1);
                     dog.writeToParcel(_data, 0);
                 } else {
                     _data.writeInt(0);
                 }
                 mRemote.transact(DogManagerImpl.TRANSACTION_addDog, _data, _reply, 0);
                 _reply.readException();
             } finally {
                 _reply.recycle();
                 _data.recycle();
             }
         }
     }

 }

到这，我们的手写binder 就完成了，然后看看 service 以及客户端 怎么调用。

先看service：

 package com.example.administrator.writebindercodeexample;

 import android.app.Service;
 import android.content.Intent;
 import android.os.IBinder;
 import android.os.RemoteException;
 import android.util.Log;

 import java.util.ArrayList;
 import java.util.List;

 public class RemoteService extends Service {

     private List<Dog> mDogsList = new ArrayList<Dog>();

     private final DogManagerImpl mBinder = new DogManagerImpl() {
         @Override
         public List<Dog> getDogList() throws RemoteException {
             return mDogsList;
         }

         @Override
         public void addDog(Dog dog) throws RemoteException {
             mDogsList.add(dog);
         }
     };

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

然后看看 启动如何在客户端bind 这个service：

 private IDogManager mService;

     private ServiceConnection sc = new ServiceConnection() {
         @Override
         public void onServiceConnected(ComponentName name, IBinder service) {
             mService = DogManagerImpl.asInterface(service);

         }

         @Override
         public void onServiceDisconnected(ComponentName name) {
             mService = null;
         }
     };

到这 就基本写完了，手写binder的好处就是 你可以自己在binder方法里 写一些log，能够更加深刻的认识到 Binder 作为 进程间通信 媒介的重要作用以及原理。

熟悉以后，还是用aidl 的方法 自动生成代码 最好。