Android中的IPC方式——使用AIDL

上一篇博文介绍了使用Messenger来进行IPC，可以发现Messenger是以串行的方式处理客户端发来的消息，如果有大量的消息发过来只能一个一个的处理，就先的不太合适。这篇博文介绍使用AIDL进行进程间通信，使用IPC。

AIDL的大概实现过程如下

1、服务端

服务端首先要创建一个Service用来坚挺客户端的链接请求，然后创建一个AIDL文件，将暴露给客户端的接口在合格AIDL文件中声明，然后在Service中实现这个AIDL接口即可。

2、客户端

客户端所要做的事情就稍微简单点，首先需要绑定服务端的Service，绑定成功后，将服务端返回的Binder对象转成AIDL接口所属的类型，接着调用AIDL中的方法就可以了。

工程目录：

首先创建一个IBookManager.aidl

package com.qian.aidlipc;

import com.qian.aidlipc.Book;

interface IBookManager {
     List<Book> getBookList();
     void addBook(in Book book);
}

在aidl文件中声明了两个方法，这两个方法就是暴露给客户端的，我们需要服务端实现。另外上面的aidl文件还用到了Book这个类，所以也要创建Book.aidl,然后添加如下内容

package com.qian.aidlipc;

parcelable Book;

Book.java是一个实体类，继承了Parcelable，可序列化

package com.qian.aidlipc;

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

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

    public int describeContents() {
        return 0;
    }

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

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

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

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

    @Override
    public String toString() {
        return String.format("[bookId:%s, bookName:%s]", bookId, bookName);
    }

}

3、远程服务端Service的实现

上面定义了AIDL接口，接下来要再服务端实现这个AIDL接口，先创建一个BookManagerService，代码如下：

package com.qian.aidlipc;

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

import android.app.Service;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Binder;
import android.os.IBinder;
import android.os.Parcel;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.os.SystemClock;
import android.util.Log;

public class BookManagerService extends Service {

    private static final String TAG = "BookManagerService";


    private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<Book>();
    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 onCreate() {
        super.onCreate();
        mBookList.add(new Book(1, "Android"));
        mBookList.add(new Book(2, "Ios"));
    }

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

上面是一个服务端Service的典型实现，首先在onCreate中中石化添加了两本图书的信息，然后创建了一个Binder对象并在onBind方法中返回它，这个对象继承自IBookManager.Stub对象，并实现了它内部的AIDL方法，这个过程在浅谈Binder机制一文中已经详细说明了，这里不多说，也就是前面所说的，将暴露给客户端的接口在Service中实现。其中实现了getBookList，addBook两个方法，实现过程也比较简单，只是为了说明原理，不用搞那么复杂，实际情况中可能会出现很复杂的情况，但是原理都一样。注意这里采用CopyOnWriteArrayList，这个CopyOnWriteArrayList支持并发读写。实际上AIDL方法是在服务端的Binder线程池中执行的，这样就有多有客户端同时访问的情况，所以需要处理线程同步问题，而这个CopyOnWriteArrayList就可以处理线程同步。

然后注册一下远程服务：

         <service
            android:name="com.qian.aidlipc.BookManagerService"
            android:process=":remote" >
        </service>

4、客户端的实现

客户端的实现，首先要绑定服务，绑定成功后将服务端返回的Binder对象转换成AIDL接口，然后通过这个接口去调用服务端的远程方法，代码如下：

package com.qian.aidlipc;

import java.util.List;
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.IBinder;
import android.os.RemoteException;
import android.util.Log;

import com.qian.aidlipc.R;

public class BookManagerActivity extends Activity {
	
    private static final String TAG = "BookManagerActivity";
    private ServiceConnection mConnection = new ServiceConnection() {
        public void onServiceConnected(ComponentName className, IBinder service) {
            IBookManager bookManager = IBookManager.Stub.asInterface(service);
           
            try {
                List<Book> list = bookManager.getBookList();
               
                Log.i(TAG, "query book list:" + list.toString());
                Book newBook = new Book(3, "夜莺与玫瑰");
                bookManager.addBook(newBook);
                Log.i(TAG, "add book:" + newBook);
                List<Book> newList = bookManager.getBookList();
                Log.i(TAG, "query book list:" + newList.toString());
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        public void onServiceDisconnected(ComponentName className) {
            
        }
    };

    @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);
    }

    @Override
    protected void onDestroy() {
        unbindService(mConnection);
        super.onDestroy();
    }

}

代码很简单，其中IBookManager bookManager = IBookManager.Stub.asInterface(service);就是将服务端返回的Binder对象转换成AIDL接口，再通过这个接口调用远程方法。注册xml然后观察一下Log：

先是getBookList。得到两本书  Android和IOS，然后调用addBook添加了一本书夜莺与玫瑰，然后又调用getBookList。和我们预想的结果是一样的，远程调用方法成功了。

最后再说明一下：

当客户端远程调用服务的方法时，被调用的方法运行在服务端的Binder线程池中，同时客户端线程会被挂起，这个时候如果服务端的方法比较耗时，就会出现客户端线程尝试加被阻塞，而如果这个客户端是UI线程的话，就会出现NR，客户端的onServiceConnected和onServiceDisconnected都是运行在UI线程，所以尽量避免UI线程调用远程方法。而服务端的方法本身就运行在Binder线程池里，所以本身可以执行大量耗时操作，所以不必再开线程执行耗时操作。另外服务端也有可能会运行客户端的回调方法，而如果客户端的这个回调方法比较耗时的话，也会造成服务端ANR，所以最好保证服务端回调接口的地方运行在非UI线程。