AIDL实例：当服务端有新书到来时，就通知每一个已经申请提醒功能的用户

功能简介：当服务端有新书到来时，就通知每一个已经申请提醒功能的用户
Book实体类

package com.example.test1.aidl;

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

public class Book implements Parcelable {

    public String bookName;
    public int bookId;

    public Book() {
    }

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

    public Book(Parcel source) {
        bookId = source.readInt();
        bookName = source.readString();
    }

    @Override
    public int describeContents() {
        // TODO 内容描述，当存在时返回1
        return 0;
    }

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

    // 反序列化
    public static final Parcelable.Creator<Book> CREATOR = new Creator<Book>() {

        @Override
        public Book[] newArray(int size) {
            // TODO 创建指定长度的对象数组
            return new Book[size];
        }

        @Override
        public Book createFromParcel(Parcel source) {
            // TODO // 从序列化的对象中创建原始对象
            return new Book(source);
        }
    };

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

}

Book的AIDL

package com.example.test1.aidl;
parcelable Book;

创建查询，增加，注册接口，删除接口 IBookManager

package com.example.test1.aidl;

import com.example.test1.aidl.Book;
import com.example.test1.aidl.IOnNewBookArrivedListener;
 interface IBookManager {
    List<Book> getBookList();
    void addBook(in Book book);
    void registerListener(IOnNewBookArrivedListener listener);
    void unregisterListener(IOnNewBookArrivedListener listener);
}

新书提醒接口 IOnNewBookArrivedListener

package com.example.test1.aidl;
import com.example.test1.aidl.Book;
interface IOnNewBookArrivedListener{
    void onNewBookArrived(in Book book);
}

XML服务注册

 <service
            android:name=".aidl.BookManagerService"
            android:process=":remote" >
 </service>

服务实现类 BookManagerService

package com.example.test1.aidl;

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

import com.example.test1.util.L;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.os.SystemClock;

public class BookManagerService extends Service {

    //解决线程同步，书籍集合
    private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<Book>();
    // 解决线程同步，判断服务状态
    private AtomicBoolean mIsServiceDestory = new AtomicBoolean(false);
    // 新书接口，这是系统专门提供用于删除跨进程listener的接口，使用方法看onNewBookArrived（）方法
    private RemoteCallbackList<IOnNewBookArrivedListener> mListenerList = new RemoteCallbackList<IOnNewBookArrivedListener>();

    @Override
    public void onCreate() {
        // TODO Auto-generated method stub
        super.onCreate();
        mBookList.add(new Book("java", 1));
        mBookList.add(new Book("ios", 2));
        // 开启任务
        new Thread(new ServiceWorker()).start();
    }

    @Override
    public void onDestroy() {
        // 停止任务
        mIsServiceDestory.set(true);
        super.onDestroy();
    }

    @Override
    public IBinder onBind(Intent intent) {
        // TODO Auto-generated method stub
        return mBinder;
    }

    private Binder mBinder = new IBookManager.Stub() {

        @Override
        public List<Book> getBookList() throws RemoteException {
            // TODO 模拟耗时操作
            SystemClock.sleep(10000);
            return mBookList;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            // TODO Auto-generated method stub
            mBookList.add(book);
        }

        @Override
        public void registerListener(IOnNewBookArrivedListener listener) throws RemoteException {
            // TODO 注册接口
            mListenerList.register(listener);
        }

        @Override
        public void unregisterListener(IOnNewBookArrivedListener listener) throws RemoteException {
            // TODO 移除接口
            mListenerList.unregister(listener);
        }
    };

    /**新书提醒任务**/
    private class ServiceWorker implements Runnable {

        @Override
        public void run() {
            // TODO Auto-generated method stub
            while (!mIsServiceDestory.get()) {
                try {
                    Thread.sleep(5000L);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                // 模拟新书
                int bookId = mBookList.size() + 1;
                Book newBook = new Book("new book#" + bookId, bookId);
                try {
                    onNewBookArrived(newBook);
                    L.d("onNewBookArrived");
                } catch (RemoteException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }

    /**提醒方法*/
    public void onNewBookArrived(Book newBook) throws RemoteException {
        // TODO 把新书加进集合
        mBookList.add(newBook);
        // RemoteCallbackList并不是List，遍历或者获取size，都要beginBroadcast，finishBroadcast配对使用
        final int N = mListenerList.beginBroadcast();
        // 当有新书时，通知所有已经注册的listener
        for (int i = 0; i < N; i++) {
            IOnNewBookArrivedListener l = mListenerList.getBroadcastItem(i);
            if (l != null) {
                try {
                    // 通知
                    l.onNewBookArrived(newBook);
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            L.d("listener.onNewBookArrived(newBook)");
        }
        mListenerList.finishBroadcast();
    }

}

客户端的实现 BookManagerActivity

package com.example.test1;

import java.util.List;

import com.example.test1.aidl.Book;
import com.example.test1.aidl.BookManagerService;
import com.example.test1.aidl.IBookManager;
import com.example.test1.aidl.IOnNewBookArrivedListener;
import com.example.test1.util.L;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.IBinder.DeathRecipient;
import android.os.RemoteException;
import android.view.View;

public class BookManagerActivity extends Activity {
    // 书籍管理接口
    private IBookManager mRemoteBookManager;
    private static final int MESSAGE_NEW_BOOK_ARRIVED = 1;
    @SuppressLint("HandlerLeak")
    private Handler mHandler = new Handler() {
        public void handleMessage(android.os.Message msg) {
            switch (msg.what) {
            case MESSAGE_NEW_BOOK_ARRIVED:
                // 接收到新书，打印出来
                L.d("recive new book:" + msg.obj);
                break;

            default:
                super.handleMessage(msg);
                break;
            }
        };
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_book_manager);
        // 绑定服务
        Intent intent = new Intent(this, BookManagerService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    public void btn(View v) {
        // 为了避免ANR，把调用放在非UI线程
        try {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    // TODO Auto-generated method stub
                    if (mRemoteBookManager != null) {
                        try {
                            List<Book> bookList = mRemoteBookManager.getBookList();
                            L.d(bookList.toString());
                        } catch (RemoteException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    private ServiceConnection mConnection = new ServiceConnection() {

        @Override
        public void onServiceDisconnected(ComponentName name) {
            // 服务断开连接
            mRemoteBookManager = null;
            L.d("IBookManager mRemoteBookManager:null");
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            // 获取
            IBookManager bookManager = IBookManager.Stub.asInterface(service);
            try {
                mRemoteBookManager = bookManager;
                // 调用方法
                List<Book> bookList = bookManager.getBookList();
                // 打印List
                L.d("list type:" + bookList.getClass().getCanonicalName());
                L.d("bookList:" + bookList.toString());
                //
                bookManager.addBook(new Book("Android艺术开发探索", 3));
                List<Book> bookList2 = bookManager.getBookList();
                L.d("bookList:" + bookList2.toString());
                // 注册新书提醒接口
                bookManager.registerListener(mOnNewBookArrivedListener);
                L.d("bookManager:registerListener");
            } catch (RemoteException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    };
    private IOnNewBookArrivedListener mOnNewBookArrivedListener = new IOnNewBookArrivedListener.Stub() {

        @Override
        public void onNewBookArrived(Book book) throws RemoteException {
            // TODO 发送到指定的
            mHandler.obtainMessage(MESSAGE_NEW_BOOK_ARRIVED, book).sendToTarget();
            L.d("mHandler:sendToTarget");
        }
    };

    /** DeathRecipient监听 */
    @SuppressWarnings("unused")
    private IBinder.DeathRecipient mDeathRecipient = new DeathRecipient() {

        @Override
        public void binderDied() {
            if (mRemoteBookManager == null) {
                return;
            }
            mRemoteBookManager.asBinder().unlinkToDeath(mDeathRecipient, 0);
            mRemoteBookManager = null;
            // TODO:这里重新绑定远程Service
        }
    };

    @Override
    protected void onDestroy() {
        // 解除接口并解绑服务
        if (mRemoteBookManager != null && mRemoteBookManager.asBinder().isBinderAlive()) {
            try {
                mRemoteBookManager.unregisterListener(mOnNewBookArrivedListener);
                L.d("IBookManager mRemoteBookManager:unregisterListener");
            } catch (RemoteException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        unbindService(mConnection);
        super.onDestroy();
    }

}