使用AIDL

Posted 2020-07-20 blueberry_mu

转载请注明出处: http://blog.csdn.net/a992036795/article/details/51579711

一、什么是aidl?
AIDL是android内部一种进程通信接口的描述语言。

二、使用aidl
aidl支持的数据类型:

• 基本数据类型 （int 、long、char 、boolean、double 等)
• String 和CharSequence
• List:只支持ArrayList，里面每个元素都必须能够被AIDL支持。
• Map:只支持HashMap，里面的每个元素都必须被AIDL支持，包括key和value.
• Pracelable，所有实现Pracelable接口的对象。

• AIDL:所有的AIDL接口本身也可以在aidl文件中使用。

  我们来写一个例子：假设服务端是一个图书馆，用来管理图书。而客户端用来添加书籍，和获得所有图书信息。
  那么首先我们需要一个类来用来描述图书信息，其次我们的这个类必须实现Parcelable接口，因为要夸进程传输。
  所以就有Book.java定义如下：

package com.blueberry.aidl;

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

/**
 * Created by blueberry on 2016/6/3.
 */
public class Book implements Parcelable{
    public int bookId ;
    public String bookName ;

    protected Book(Parcel in) {
        bookId = in.readInt();
        bookName = in.readString();
    }

    public Book() {
    }

    public Book(String bookName, int bookId) {
        this.bookName = bookName;
        this.bookId = bookId;
    }

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

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeInt(bookId);
        dest.writeString(bookName);
    }

    @Override
    public String toString() {
        return "Book{" +
                "bookId=" + bookId +
                ", bookName='" + bookName + '\\'' +
                '}';
    }


    public static final Creator<Book> CREATOR = new Creator<Book>() {
        @Override
        public Book createFromParcel(Parcel in) {
            return new Book(in);
        }

        @Override
        public Book[] newArray(int size) {
            return new Book[size];
        }
    };
}

注意其中必须重写writeToParcel（）方法，以及必须要有一个内部类CREATOR用来反序列化。
下面我们创建Book对应的aidl文件，来声明Book类。
Book.aidl文件:

// Book.aidl
package com.blueberry.aidl;

//声明Book
parcelable Book ;

接着我们需要一个BookManager接口来实现客户端对服务端的调用
IBookManager.aidl:

// IBookManager.aidl
package com.blueberry.aidl;

//即使在同一个包下也要声明
import com.blueberry.aidl.Book;
import com.blueberry.aidl.OnBookArrivedListener;

interface IBookManager {
    /**
    * 获得Books,实际传递的是ArrayList
    */
    List<Book> getBookList();

    /**
    * 添加Book
    */
    void addBook(in Book book);
}

注意 addBook()方法 java中接口的参数声明多一个描述符，in,来描述参数传递的方向，可以为in ,out或者 inout。in表示输入型参数，out表示输出型参数，inout表示输入输出参数。另外aidl接口描述中，不支持声明静态常量，这一点区别于传统的接口。

那么aidl文件写完了，我们编译一下看看，对应的文件夹下生成的java，文件
我这里先全部贴出：

/*
 * This file is auto-generated.  DO NOT MODIFY.
 * Original file: E:\\\\AsWorkSpace\\\\test\\\\test04\\\\app\\\\src\\\\main\\\\aidl\\\\com\\\\blueberry\\\\aidl\\\\IBookManager.aidl
 */
package com.blueberry.aidl;

public interface IBookManager extends android.os.IInterface {
    /**
     * Local-side IPC implementation stub class.
     */
    public static abstract class Stub extends android.os.Binder implements com.blueberry.aidl.IBookManager {
        private static final java.lang.String DESCRIPTOR = "com.blueberry.aidl.IBookManager";

        /**
         * Construct the stub at attach it to the interface.
         */
        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

        /**
         * Cast an IBinder object into an com.blueberry.aidl.IBookManager interface,
         * generating a proxy if needed.
         */
        public static com.blueberry.aidl.IBookManager asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.blueberry.aidl.IBookManager))) {
                return ((com.blueberry.aidl.IBookManager) iin);
            }
            return new com.blueberry.aidl.IBookManager.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_getBookList: {
                    data.enforceInterface(DESCRIPTOR);
                    java.util.List<com.blueberry.aidl.Book> _result = this.getBookList();
                    reply.writeNoException();
                    reply.writeTypedList(_result);
                    return true;
                }
                case TRANSACTION_addBook: {
                    data.enforceInterface(DESCRIPTOR);
                    com.blueberry.aidl.Book _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.blueberry.aidl.Book.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    this.addBook(_arg0);
                    reply.writeNoException();
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

        private static class Proxy implements com.blueberry.aidl.IBookManager {
            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;
            }

            /**
             * 获得Books,实际传递的是ArrayList
             */
            @Override
            public java.util.List<com.blueberry.aidl.Book> getBookList() throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                java.util.List<com.blueberry.aidl.Book> _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.createTypedArrayList(com.blueberry.aidl.Book.CREATOR);
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }

            /**
             * 添加Book
             */
            @Override
            public void addBook(com.blueberry.aidl.Book book) 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 ((book != null)) {
                        _data.writeInt(1);
                        book.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }

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

    /**
     * 获得Books,实际传递的是ArrayList
     */
    public java.util.List<com.blueberry.aidl.Book> getBookList() throws android.os.RemoteException;

    /**
     * 添加Book
     */
    public void addBook(com.blueberry.aidl.Book book) throws android.os.RemoteException;
}

可以看到这个文件主要有一个接口（IBookManager)和2个实现类（Stub、Proxy)。
我们可以看到 IBookManager实际就是我们在aidl文件中定义的那个接口，只是它继承了一个IInterface接口。看看IInterface接口的描述:

/**
 * Base class for Binder interfaces.  When defining a new interface,
 * you must derive it from IInterface.
 */
public interface IInterface
{
    /**
     * Retrieve the Binder object associated with this interface.
     * You must use this instead of a plain cast, so that proxy objects
     * can return the correct result.
     */
    public IBinder asBinder();
}

可以看到使用binder通信，每个接口都必须继承自这个接口 。
我们现在来看Stub类的定义：

public static abstract class Stub extends android.os.Binder implements com.blueberry.aidl.IBookManager {
        private static final java.lang.String DESCRIPTOR = "com.blueberry.aidl.IBookManager";

        /**
         * Construct the stub at attach it to the interface.
         */
        public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

        /**
         * Cast an IBinder object into an com.blueberry.aidl.IBookManager interface,
         * generating a proxy if needed.
         */
        public static com.blueberry.aidl.IBookManager asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.blueberry.aidl.IBookManager))) {
                return ((com.blueberry.aidl.IBookManager) iin);
            }
            return new com.blueberry.aidl.IBookManager.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_getBookList: {
                    data.enforceInterface(DESCRIPTOR);
                    java.util.List<com.blueberry.aidl.Book> _result = this.getBookList();
                    reply.writeNoException();
                    reply.writeTypedList(_result);
                    return true;
                }
                case TRANSACTION_addBook: {
                    data.enforceInterface(DESCRIPTOR);
                    com.blueberry.aidl.Book _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.blueberry.aidl.Book.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    this.addBook(_arg0);
                    reply.writeNoException();
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }
    }
 static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
        static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);

可以看到它继承自Binder，并实现了IBookManager的asBinder()方法，但并没有实现IBookManager的addBook()和getBookList()方法，这些犯法最终留给他的子类去是实现。
首先，看他的的构造方法：

   private static final java.lang.String DESCRIPTOR = "com.blueberry.aidl.IBookManager";
 public Stub() {
            this.attachInterface(this, DESCRIPTOR);
        }

它将调用父类binder的 attachInterface方法，将自身，以及他的描述符传递类进去。我们可以看看这个方法的定义：

 /**
     * Convenience method for associating a specific interface with the Binder.
     * After calling, queryLocalInterface() will be implemented for you
     * to return the given owner IInterface when the corresponding
     * descriptor is requested.
     */
    public void attachInterface(IInterface owner, String descriptor) {
        mOwner = owner;
        mDescriptor = descriptor;
    }

这里的大致意思是：调用这个方法之后，我们到时可以使用queryLocalnterface（）这个方法传入描述符DESTRIPTOR来找到这个binder.

所以紧接着就有这个方法：

 /**
         * Cast an IBinder object into an com.blueberry.aidl.IBookManager interface,
         * generating a proxy if needed.
         */
        public static com.blueberry.aidl.IBookManager asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.blueberry.aidl.IBookManager))) {
                return ((com.blueberry.aidl.IBookManager) iin);
            }
            return new com.blueberry.aidl.IBookManager.Stub.Proxy(obj);
        }

这里调用queryLocalInterface()来查询本地是否有这个binder.如果有的话，就将本地的这个binder返回，否则的话将使用 这个binder对象构造出一个代理类Proxy返回。

这里就说明了如果本地有这个binder，就使用本地的这个binder。否则这个binder就是远程的，那我就将这个binder作为参数构造出一个代理类Proxy来使用。

那我们就先放下onTransact（）方法，来看Proxy类。实际上onTransact()方法实在夸进程调时才会调用，而且实在服务端被调用。

我们先看Proxy类：

  private static class Proxy implements com.blueberry.aidl.IBookManager {
            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;
            }

            /**
             * 获得Books,实际传递的是ArrayList
             */
            @Override
            public java.util.List<com.blueberry.aidl.Book> getBookList() throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                java.util.List<com.blueberry.aidl.Book> _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.createTypedArrayList(com.blueberry.aidl.Book.CREATOR);
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }

            /**
             * 添加Book
             */
            @Override
            public void addBook(com.blueberry.aidl.Book book) 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 ((book != null)) {
                        _data.writeInt(1);
                        book.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }
        }

这个很明显是一个代理模式，在构造方法将被代理的类传递进来，然后真正是在执行这个类的方法，实际就是执行mRemote的方法。

 private android.os.IBinder mRemote;

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

我们接着来看他的 getBookList()方法和addBook（）方法

  /**
             * 获得Books,实际传递的是ArrayList
             */
            @Override
            public java.util.List<com.blueberry.aidl.Book> getBookList() throws android.os.RemoteException {
                android.os.Parcel _data = android.os.Parcel.obtain();
                android.os.Parcel _reply = android.os.Parcel.obtain();
                java.util.List<com.blueberry.aidl.Book> _result;
                try {
                    _data.writeInterfaceToken(DESCRIPTOR);
                    mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
                    _reply.readException();
                    _result = _reply.createTypedArrayList(com.blueberry.aidl.Book.CREATOR);
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
                return _result;
            }

            /**
             * 添加Book
             */
            @Override
            public void addBook(com.blueberry.aidl.Book book) 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 ((book != null)) {
                        _data.writeInt(1);
                        book.writeToParcel(_data, 0);
                    } else {
                        _data.writeInt(0);
                    }
                    mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
                    _reply.readException();
                } finally {
                    _reply.recycle();
                    _data.recycle();
                }
            }

我们可以看到，他使用Parcel创建 出输入参数，以及返回参数最后是调用了被代理类即 mRemote的 transact方法。因为这个mRemote是远程服务端传递过来的。
所以这个方法的调用执行将发生在服务端。
我们来看一下这个方法子在Binder中的定义：

  /**
     * Default implementation rewinds the parcels and calls onTransact.  On
     * the remote side, transact calls into the binder to do the IPC.
     */
    public final boolean transact(int code, Parcel data, Parcel reply,
            int flags) throws RemoteException {
        if (false) Log.v("Binder", "Transact: " + code + " to " + this);
        if (data != null) {
            data.setDataPosition(0);
        }
        boolean r = onTransact(code, data, reply, flags);
        if (reply != null) {
            reply.setDataPosition(0);
        }
        return r;
    }

我们可以看到最后执行了 它的onTransact()方法。
那么，现在我们就明白了。因为服务端和客户端有着同样的aidl文件，这个远程对象实际是 服务端那边声明的Stub类，它将执行的是Stub类中onTransact()方法
那么我们就来看，Stub类中的onTransact()方法：

  @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_getBookList: {
                    data.enforceInterface(DESCRIPTOR);
                    java.util.List<com.blueberry.aidl.Book> _result = this.getBookList();
                    reply.writeNoException();
                    reply.writeTypedList(_result);
                    return true;
                }
                case TRANSACTION_addBook: {
                    data.enforceInterface(DESCRIPTOR);
                    com.blueberry.aidl.Book _arg0;
                    if ((0 != data.readInt())) {
                        _arg0 = com.blueberry.aidl.Book.CREATOR.createFromParcel(data);
                    } else {
                        _arg0 = null;
                    }
                    this.addBook(_arg0);
                    reply.writeNoException();
                    return true;
                }
            }
            return super.onTransact(code, data, reply, flags);
        }

可以看到，他最终调用了服务端Stub的 addBook()方法以及getBookList()方法。
这2个方法最后发生在服务端。
这样就完成了一次原生调用。

三、接着我贴一下服务端Service的实现，以及客户端的调用。

public class SimpleService extends Service {

    private static final String TAG = "SimpleService";

    private CopyOnWriteArrayList<Book> books = new CopyOnWriteArrayList<>();

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return new IBookManager.Stub(){

            @Override
            public List<Book> getBookList() throws RemoteException {
                Log.i(TAG, "getBookList: books: " +books);
                Log.i(TAG, "current Thread :" +Thread.currentThread());
                return books;
            }

            @Override
            public void addBook(Book book) throws RemoteException {
                Log.i(TAG, "addBook: book: "+book);
                Log.i(TAG, "current Thread :"+Thread.currentThread());
                books.add(book);
            }
        };
    }
}

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";

    private Button btnAdd,btnGet;
    private TextView tvLog;

    private int count;

    private IBookManager mBookManager;
    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mBookManager = IBookManager.Stub.asInterface(service) ;
            Log.i(TAG, "onServiceConnected: ");
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.i(TAG, "onServiceDisconnected: ");
        }
    } ;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent = new Intent(this,SimpleService.class);
        bindService(intent,conn, Context.BIND_AUTO_CREATE);
        initView();
    }

    private void initView() {
        btnAdd = (Button) findViewById(R.id.btn_add);
        btnGet = (Button) findViewById(R.id.btn_get);
        tvLog = (TextView) findViewById(R.id.tv_log);

        btnAdd.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Book book = new Book(count,"book#"+count);
                count++;
                try {
                    mBookManager.addBook(book);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                Log.i(TAG, "add book :"+book);
                Log.i(TAG, "current thread: "+Thread.currentThread());
            }
        });


        btnGet.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                try {
                    List<Book> books = mBookManager.getBookList();
                    Log.i(TAG, "books :"+books);
                    Log.i(TAG, "current thread: "+Thread.currentThread());
                    tvLog.setText("");
                    for(Book book:books){
                        tvLog.append(book.toString());
                        tvLog.append("\\n");
                    }
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

四、可以为binder设置死亡代理，这样在binder销毁之后我们就可以接受到消息。

private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
        @Override
        public void binderDied() {
            Log.i(TAG, "binderDied: ");
        }
    } ;
    private ServiceConnection conn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mBookManager = IBookManager.Stub.asInterface(service) ;
            try {
                /*设置死亡代理*/
                service.linkToDeath(mDeathRecipient ,0 );
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            Log.i(TAG, "onServiceConnected: ");
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.i(TAG, "onServiceDisconnected: ");
        }
    } ;

五、最后在扩展一个
假如我们不想每次都使用getBookList来获取图书列表，我们希望客户端可以在服务端设置一个监听器。使得客户端可以接受服务端的消息回调。

那么我们就需要定义一个接口来定义回调方法，因为是夸进程所以我们需要使用aidl文件来定义。

// OnBookArrivedListener.aidl
package com.blueberry.aidl;

// Declare any non-default types here with import statements

import com.blueberry.aidl.Book;

interface OnBookArrivedListener {
  void  onBookArrived(in Book book) ;
}

还需要在IBookManager.aidl添加2个方法用来 注册观察着，和移除观察者。

// IBookManager.aidl
package com.blueberry.aidl;

//即使在同一个包下也要声明
import com.blueberry.aidl.Book;
import com.blueberry.aidl.OnBookArrivedListener;

interface IBookManager {
    /**
    * 获得Books,实际传递的是ArrayList
    */
    List<Book> getBookList();

    /**
    * 添加Book
    */
    void addBook(in Book book);

    /**
    * 添加监听器
    */
    void registerListener(in OnBookArrivedListener listener) ;

    /**
    * 移除监听器
    */
    void remoteListener(in OnBookArrivedListener listener);

}

同样我们需要在服务端 用一个容器来存储这些观察者。

package com.blueberry.test04;

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

import com.blueberry.aidl.Book;
import com.blueberry.aidl.IBookManager;
import com.blueberry.aidl.OnBookArrivedListener;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class SimpleService extends Service {
    private static final String TAG = "SimpleService";

    /*最终会将CopyOnWriteArrayList转化为ArrayList进行夸进程传输*/
    private CopyOnWriteArrayList<Book> books = new CopyOnWriteArrayList<>() ;

    /**
     * RemoteCallbackList
     */
    private RemoteCallbackList<OnBookArrivedListener> listeners = new RemoteCallbackList<>() ;

    private IBookManager.Stub stub =new IBookManager.Stub(){

        @Override
        public List<Book> getBookList() throws RemoteException {
            Log.i(TAG, "current thread: "+Thread.currentThread());
            Log.i(TAG, "getBookList: Books.class: "+books.getClass());
            return books;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            Log.i(TAG, "current thread: "+Thread.currentThread());
            Log.i(TAG, "addBook: book: "+book);
            books.add(book) ;
         int N =  listeners.beginBroadcast();
            for (int i = 0; i < N; i++) {
                OnBookArrivedListener broadcastItem = listeners.getBroadcastItem(i);
                if(broadcastItem!=null){
                    try {

                        broadcastItem.onBookArrived(book);
                    }catch (RemoteException e){
                        e.printStackTrace();
                    }
                }
            }
            listeners.finishBroadcast();
        }

        @Override
        public void registerListener(OnBookArrivedListener listener) throws RemoteException {
           listeners.register(listener) ;
        }

        @Override
        public void remoteListener(OnBookArrivedListener listener) throws RemoteException {
           listeners.unregister(listener);
            Log.i(TAG, "remoteListener: ok.");
        }
    };
    public SimpleService() {
    }

    private int count = 0;
    @Override
    public IBinder onBind(Intent intent) {

        new Thread(){
            @Override
            public void run() {
               while (true){
                   try {
                       Thread.sleep(2000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   Book book = new Book("book#"+count,count);
                   count++ ;
                   try {
                       stub.addBook(book);
                   } catch (RemoteException e) {
                       e.printStackTrace();
                   }
               }
            }
        }.start();
        return stub ;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.i(TAG, "onDestroy: ");
    }
}

注意我并没有使用CopyOnWriteArrayList来存储观察着们，原因是：
如果使用这种集合，我们在取消注册观察者即调用remoteListener(OnBookArrivedListener listener)将会无作用，会因为这个参数中传递过来的对象，在跨进程时将会被序列化，以及反序列化。将导致和服务端的不是同一个对象，所以不会移除的这个监听器。

所以我们选择使用RemoteCallbackList 来存储。RemoteCallbakList使用一个ArrayMap< IBinder, Callback> 来存数这些监听着们。
我们来看一下它的register方法 和remove方法

   */
    public boolean register(E callback, Object cookie) {
        synchronized (mCallbacks) {
            if (mKilled) {
                return false;
            }
            IBinder binder = callback.asBinder();
            try {
                Callback cb = new Callback(callback, cookie);
                binder.linkToDeath(cb, 0);
                mCallbacks.put(binder, cb);
                return true;
            } catch (RemoteException e) {
                return false;
            }
        }
    }

  public boolean unregister(E callback) {
        synchronized (mCallbacks) {
            Callback cb = mCallbacks.remove(callback.asBinder());
            if (cb != null) {
                cb.mCallback.asBinder().unlinkToDeath(cb, 0);
                return true;
            }
            return false;
        }
    }

可以看到它调用监听器的 asBinder（）方法作为键来存储对象，
我们上文分析过Stub、和Proxy类，知道Stub返回的 this, Proxy返回的是mRemote。 而如果是夸进程时，这个mRemote正时服务端Stub返回的this.
所以这种方法可行。