代碼庫/新添加通知AIDL

Book  Parcelable類：

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

/**
 * Created by YRC on 2017/12/5.
 */

public class Book implements Parcelable {
    public int bookId;
    public String bookName;
    public Book(){
    }
    public Book(int bookId,String bookName){
        this.bookId=bookId;
        this.bookName=bookName;
    }
    private Book(Parcel in) {
        bookId=in.readInt();
        bookName=in.readString();
    }

    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];
        }
    };

    @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 String.format("[bookId:%s, bookName:%s]", bookId, bookName);
    }
}

MainAc

import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

import java.util.List;

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "BookManagerActivity";
    private static final int MESSAGE_NEW_BOOK_ARRIVED = 1;

    private IBookManager mRemoteBookManager;


    private Handler mHandler=new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            switch (msg.what){
                case MESSAGE_NEW_BOOK_ARRIVED:
                    Log.d(TAG, "receive new book :" + msg.obj);
                    break;
                default:
                    break;

            }
            return false;
        }
    });

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent=new Intent(this,AidlService.class);
        bindService(intent,serviceConnection,BIND_AUTO_CREATE);
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                try {
//                    List<Book> newList = mRemoteBookManager.getBookList();
//                } catch (RemoteException e) {
//                    e.printStackTrace();
//                }
//            }
//        }).start();
    }



    private ServiceConnection serviceConnection=new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mRemoteBookManager= IBookManager.Stub.asInterface(service);
            try {
                mRemoteBookManager.asBinder().linkToDeath(deathRecipient,0);
                Book book=new Book(3,"pro-e");
                mRemoteBookManager.addBook(book);
                List<Book> newList=mRemoteBookManager.getBookList();
                Log.d(TAG,"After addBook is : "+newList.toString());
                mRemoteBookManager.registerListener(mIOnNewBookArrivedListener);
                Log.d(TAG,"success");
            } catch (RemoteException e) {
                e.printStackTrace();
            }



        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    private IOnNewBookArrivedListener mIOnNewBookArrivedListener=new IOnNewBookArrivedListener.Stub() {
        @Override
        public void onNewBookArrived(Book newBook) throws RemoteException {
            Message message=new Message();
            message.what=MESSAGE_NEW_BOOK_ARRIVED;
            message.obj=newBook;
            mHandler.sendMessage(message);
        }
    };

    private IBinder.DeathRecipient deathRecipient=new IBinder.DeathRecipient() {
        @Override
        public void binderDied() {
            try {
                mRemoteBookManager.asBinder().linkToDeath(deathRecipient,0);
                Intent intent=new Intent(MainActivity.this,AidlService.class);
                bindService(intent,serviceConnection,BIND_AUTO_CREATE);
                mRemoteBookManager=null;
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    };


    @Override
    protected void onDestroy() {
        if (mRemoteBookManager!=null&&mRemoteBookManager.asBinder().isBinderAlive()){
            try {
                mRemoteBookManager.unRegisterListener(mIOnNewBookArrivedListener);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        unbindService(serviceConnection);
        super.onDestroy();

    }
}

AidlService

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.support.annotation.Nullable;
import android.util.Log;

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

/**
 * Created by YRC on 2017/12/5.
 */

public class AidlService extends Service {
    private AtomicBoolean mIsServiceDestoryed = new AtomicBoolean(false);
    private static final String TAG="AidlService";
    //讀多寫少
    private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<Book>();

    private RemoteCallbackList<IOnNewBookArrivedListener> mListener=new RemoteCallbackList<>();


    @Override
    public void onCreate() {
        super.onCreate();
        mBookList.add(new Book(1,"android"));
        mBookList.add(new Book(2,"ios"));
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (!mIsServiceDestoryed.get()){
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    int bookId=mBookList.size()+1;
                    Book book=new Book(bookId,"new Book"+bookId);
                    onNewBookArrived(book);
                    Log.d(TAG,"success");
                }
            }
        }).start();
    }

    private void onNewBookArrived(Book book) {
        mBookList.add(book);
        Log.d(TAG,"new BookList"+mBookList.toString());
        final  int N=mListener.beginBroadcast();
        for (int i=0;i<N;i++){
            IOnNewBookArrivedListener iOnNewBookArrivedListener=mListener.getBroadcastItem(i);
            if (iOnNewBookArrivedListener!=null){
                try {
                    iOnNewBookArrivedListener.onNewBookArrived(book);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
        mListener.finishBroadcast();
    }


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

    private Binder mBinder=new IBookManager.Stub() {
        @Override
        public List<Book> getBookList() throws RemoteException {
            return mBookList;
        }

        @Override
        public void addBook(Book book) throws RemoteException {
            mBookList.add(book);
        }

        @Override
        public void registerListener(IOnNewBookArrivedListener listener) throws RemoteException {
            mListener.register(listener);
            //廣播中的回調數
            final int N = mListener.beginBroadcast();
            Log.d(TAG,"registerListener, current size:"+N);
            mListener.finishBroadcast();
        }

        @Override
        public void unRegisterListener(IOnNewBookArrivedListener listener) throws RemoteException {
            boolean success=mListener.unregister(listener);
            if (success){
                Log.d(TAG,"success");
            }else {
                Log.d(TAG,"false");
            }

        }
    };

    @Override
    public void onDestroy() {
        mIsServiceDestoryed.set(true);
        super.onDestroy();

    }
}

book.aidl

parcelable Book;

IBookManager.aidl

import com.example.yrc.aidl.Book;
import com.example.yrc.aidl.IOnNewBookArrivedListener;

interface IBookManager {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    List<Book> getBookList();
    void addBook(in Book book);
    void registerListener(IOnNewBookArrivedListener listener);
    void unRegisterListener(IOnNewBookArrivedListener listener);
}

IOnNewBookArrivedListener.aidl

import com.example.yrc.aidl.Book;

interface IOnNewBookArrivedListener {
    /**
     * Demonstrates some basic types that you can use as parameters
     * and return values in AIDL.
     */
    void onNewBookArrived(in Book newBook);
}