Android AIDL开发Binder应用中注意事项

1 前言

在我们的应用开发中，我们常常有跨进程通信的需求，如果使用AIDL方式，就是用Binder进行通信，往往会新建AIDL文件来定义好服务，服务端实现这些服务，而客户端会具体调用这些服务。

关于怎么新建AIDL文件，以及如何实现客户端与服务端，这里就不做讨论了，网上由于大把的教程，这里主要讨论下需要开发中注意的事项。

需要注意的事项如下：

2 Binder通信注意事项

1 AIDL文件路径问题

当我们在studio中新建AIDL文件时，由于Server与Client需要共享原始的Bean与AIDL文件，并且两端需要有共同的包名，因此，我们往往通过studio中的如下命令来新建AIDL文件：



这样我们往往在src/main/目录下会新建一个aidl包，如下：



这个包与java包同级，同时为了避免aidl包中的类我们在编译的时候找不到，应该在build.gradle中添加如下配置：

sourceSets {
main {
java.srcDirs = ['src/main/java', 'src/main/aidl']
aidl.srcDirs = ['src/main/aidl']
}
}

不管是客户端还是服务器，都需要以上的配置，这样就能保证进行AIDL部分在客户端与服务端都具有相同的包名，便于序列化与反序列化。

2 服务端代码需要考虑多线程访问的同步问题

一般来说，服务端需要处理多个客户端同时访问的情况，因此必须考虑多线程的问题，可以采用锁住数据源的方式同步，也可以采用一些类比如CopyOnWriteArrayList< T >来解决。

例如下面的例子，使用CopyOnWriteArrayList定义了mBookList，这样服务端端对mBookList的操作都是线程安全的，比如添加，更新，删除等：

private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<>();
......
/**
* 运行在Binder线程池中
*/
private Binder mBinder = new IBookManager.Stub(){
@Override
public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

}

@Override
public List<Book> getBookList() throws RemoteException {
Log.d(TAG,"thread :" + Thread.currentThread().getName());
//            try {
//                Thread.sleep(10000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
return mBookList;
}

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

3 Binder通信中的观察者模式

在Binder通信中，一般来说是客户端主动去调用服务端的服务，但是在某些情况下，需要服务端去通知客户端，比如，某些数据已经准备好，客户端可以开始调用xxx服务了，这个时候就需要用到观察者模式了，一般来说的是这样实现的。

客户端作为观察者，服务端作为被观察者，客户端注册某个监听到服务端，服务端当数据准备好或者条件满足，通过监听的回调通知客户端。

由于Binder通信是跨进程的，一般来说监听是需要跨进程传输，为了便于客户端的注册与反注册监听器，需要使用RemoteCallbackList< E >辅助类来实现监听的注册与反注册。

一个简单的例子如下：

服务端与客户端AIDL文件：

interface IBookManager {
/**
* Demonstrates some basic types that you can use as parameters
* and return values in AIDL.
*/
void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
double aDouble, String aString);

/*
* 获取所有的book
* */
List<Book> getBookList();

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

void registerListener(in IOnNewBookArrivedListener listener);

void unRegisterListener(in IOnNewBookArrivedListener listener);
}

interface IOnNewBookArrivedListener {
/**
* Demonstrates some basic types that you can use as parameters
* and return values in AIDL.
*/
void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
double aDouble, String aString);
//新书到来
void onNewBookArrived(in Book book);
}

BookManagerService实现：

/**
* Created by qiyei2015 on 2017/4/7.
* 1273482124@qq.com
*/
public class BookManagerService extends Service {
private static final String TAG = "BMS";

//需要同步
private AtomicBoolean mIsServiceDestroy = new AtomicBoolean(false);
private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<>();
//无法取消注册
//private CopyOnWriteArrayList<IOnNewBookArrivedListener> mListenerList = new CopyOnWriteArrayList<>();

//使用这个来取消注册
private RemoteCallbackList<IOnNewBookArrivedListener> mRemoteCallbackList = new RemoteCallbackList<>();

/**
* 运行在Binder线程池中
*/
private Binder mBinder = new IBookManager.Stub(){
@Override
public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

}

@Override
public List<Book> getBookList() throws RemoteException {
Log.d(TAG,"getBookList thread :" + Thread.currentThread().getName());
return mBookList;
}

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

@Override
public void registerListener(IOnNewBookArrivedListener listener) throws RemoteException {
mRemoteCallbackList.register(listener);
Log.d(TAG,"mListenerList size:" + mRemoteCallbackList.beginBroadcast());
mRemoteCallbackList.finishBroadcast();
}

@Override
public void unRegisterListener(IOnNewBookArrivedListener listener) throws RemoteException {
mRemoteCallbackList.unregister(listener);
Log.d(TAG,"mListenerList size:" + mRemoteCallbackList.beginBroadcast());
mRemoteCallbackList.finishBroadcast();
}
};

@Nullable
@Override
public IBinder onBind(Intent intent) {
Log.d(TAG,"onBind");
return mBinder;
}

@Override
public void onCreate() {
super.onCreate();
Log.d(TAG,"onCreate");
init();
new Thread(new ServiceWorker()).start();
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.d(TAG,"onStartCommand");
return super.onStartCommand(intent, flags, startId);
}

@Override
public boolean onUnbind(Intent intent) {
Log.d(TAG,"onUnbind");
return super.onUnbind(intent);
}

@Override
public void onDestroy() {
mIsServiceDestroy.set(true);
Log.d(TAG,"onDestroy");
super.onDestroy();
}

private void init(){
for (int i = 0;i < 10;i++){
Book book = new Book(i+1,"book_" + (i+1));
mBookList.add(book);
}
}

public class ServiceWorker implements Runnable{
@Override
public void run() {

while (!mIsServiceDestroy.get()){
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
int bookId = mBookList.size() + 1;
Book book = new Book(bookId,"book_" + bookId);
try {
notifyClientNewBook(book);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}

/**
* 通知客户端新书到来
* @param book
* @throws Exception
*/
private void notifyClientNewBook(Book book) throws Exception{
mBookList.add(book);

int size = mRemoteCallbackList.beginBroadcast();

Log.d(TAG,"notifyClientNewBook: "+ book.toString());
for (int i = 0;i <size;i++){
IOnNewBookArrivedListener listener = mRemoteCallbackList.getBroadcastItem(i);
Log.d(TAG,"notify listener: "+ listener.toString());
listener.onNewBookArrived(book);
}
mRemoteCallbackList.finishBroadcast();
}

/**
* 检查BookServiceDe调用权限
* @return
*/
private boolean checkBookServicePermission(){
int check = checkCallingOrSelfPermission("com.qiyei.ipc.book.ACCESS_BOOK_SERVICE");
return check == PackageManager.PERMISSION_DENIED;
}
}

客户端实现：

public class MainActivity extends AppCompatActivity {

private static final String TAG = "Client";
private static final int MESSAGE_NEW_BOOK = 1;

private Context mContext;

private TextView mTextView;
private Button mButton;
private Button mClear;
private Button mButton2;

private IBookManager mBookManager;

private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
if (msg.what == MESSAGE_NEW_BOOK){
Book book = (Book) msg.obj;
mTextView.setText(book.toString());
}
}
};

/**
* Binder死亡代理 ，Binder死亡时会回调该方法
*/
private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
@Override
public void binderDied() {
if (mBookManager == null){
return;
}
mBookManager.asBinder().unlinkToDeath(mDeathRecipient,0);
mBookManager = null;
//重新连接服务
bindBookService();
}
};

/**
* 运行在主线程中
*/
private ServiceConnection mServiceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.d(TAG,"onServiceConnected thread :" + Thread.currentThread().getName());
mBookManager = IBookManager.Stub.asInterface(service);
try {
mBookManager.asBinder().linkToDeath(mDeathRecipient,0);
mBookManager.registerListener(mListener);
} catch (RemoteException e) {
e.printStackTrace();
}
try {
mTextView.setText(mBookManager.getBookList().toString());
} catch (RemoteException e) {
e.printStackTrace();
}
}

@Override
public void onServiceDisconnected(ComponentName name) {
//bindBookService();
}
};

/**
* Service调用，运行在Client端的Binder线程中
*/
private IOnNewBookArrivedListener mListener = new IOnNewBookArrivedListener.Stub(){

@Override
public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

}

@Override
public void onNewBookArrived(Book book) throws RemoteException {
Log.d(TAG,"onNewBookArrived thread :" + Thread.currentThread().getName());
Message message = Message.obtain();
message.what = MESSAGE_NEW_BOOK;
message.obj = book;
mHandler.sendMessage(message);
}
};

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mContext = this;
initView();

}

private void initView(){
mTextView = (TextView) findViewById(R.id.tv1);
mClear = (Button) findViewById(R.id.btn0);
mClear.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mTextView.setText("");
}
});
mButton = (Button) findViewById(R.id.btn1);
mButton.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
bindBookService();
}
});
mButton2 = (Button) findViewById(R.id.btn2);
mButton2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
unbindService(mServiceConnection);
startActivity(new Intent(mContext,TestActivity.class));
}
});
}

@Override
protected void onDestroy() {
super.onDestroy();

if (mBookManager != null && mBookManager.asBinder().isBinderAlive()){
try {
mBookManager.unRegisterListener(mListener);
Log.d(TAG,"unRegister listener ");
} catch (RemoteException e) {
e.printStackTrace();
}
}

unbindService(mServiceConnection);
}

/**
* 绑定BookService
*/
private void bindBookService(){
Intent intent = new Intent();
//这里需要指定Action 与packageName
intent.setAction("android.intent.action.BOOK_MANAGER_SERVICE");
intent.setPackage("com.qiyei.ipcserver");

bindService(intent,mServiceConnection, BIND_AUTO_CREATE);
}
}

客户端直接在MainActivty去连接服务，并且在绑定成功后的onServiceConnected(ComponentName name, IBinder service)去注册IOnNewBookArrivedListener ，客户端自己实现该监听器，并在Activity的onDestroy中去取消注册与解绑服务。

4 Binder通信中的线程问题

对于服务端来说，客户端调用服务端的服务，具体的服务方法运行在服务端的Binder线程池中，并没有运行在服务端的主线程中。并且调用会阻塞。

在上面的服务BookManagerService中：

/**
* 运行在Binder线程池中
*/
private Binder mBinder = new IBookManager.Stub(){
@Override
public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

}

@Override
public List<Book> getBookList() throws RemoteException {
Log.d(TAG,"getBookList thread :" + Thread.currentThread().getName());
return mBookList;
}

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

@Override
public void registerListener(IOnNewBookArrivedListener listener) throws RemoteException {
mRemoteCallbackList.register(listener);
Log.d(TAG,"mListenerList size:" + mRemoteCallbackList.beginBroadcast());
mRemoteCallbackList.finishBroadcast();
}

@Override
public void unRegisterListener(IOnNewBookArrivedListener listener) throws RemoteException {
mRemoteCallbackList.unregister(listener);
Log.d(TAG,"mListenerList size:" + mRemoteCallbackList.beginBroadcast());
mRemoteCallbackList.finishBroadcast();
}

};

当运行时，可以看到如下输出：



可以看到，确实运行在服务端的Binder线程中

对于客户端来说， 绑定服务成功后的回调ServiceConnection是运行在主线程(UI线程中的)，同时由于调用服务端的服务可能会阻塞，因此尽量避免在主线程中去调用服务端的服务。另外，服务端回调客户端的监听Listener中的方法却是运行在客户端的Binder线程池中，因此不能直接更新UI，我们运行客户端的，可以看到如下：



5 客户端Binder意外死亡时重连的问题

一般来说，我们需要考虑到服务端程序的意外终止，这个时候Binder就会意外死亡，这个时候我们就需要重新连接服务。一般来说有两种方法，一种在ServiceConnection的onServiceDisconnected中进行重新连接服务，但是需要区分正常的断开服务，另外一种是给Binder设置DeathRecipient监听，当Binder意外死亡时会回调监听中的binderDied()方法

/**
* Binder死亡代理 ，Binder死亡时会回调该方法
*/
private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient() {
@Override
public void binderDied() {
if (mBookManager == null){
return;
}
mBookManager.asBinder().unlinkToDeath(mDeathRecipient,0);
mBookManager = null;
//重新连接服务
bindBookService();
}
};
/**
* 运行在主线程中
*/
private ServiceConnection mServiceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.d(TAG,"onServiceConnected thread :" + Thread.currentThread().getName());
mBookManager = IBookManager.Stub.asInterface(service);
try {
mBookManager.asBinder().linkToDeath(mDeathRecipient,0);
mBookManager.registerListener(mListener);
} catch (RemoteException e) {
e.printStackTrace();
}
try {
mTextView.setText(mBookManager.getBookList().toString());
} catch (RemoteException e) {
e.printStackTrace();
}
}

@Override
public void onServiceDisconnected(ComponentName name) {
//bindBookService();
}
};

这样当Binder意外死亡时，会回调binderDied，我们在里面去重连服务即可。

6 Binder通信的权限问题

我们在Binder通信中不可避免的会用到权限的问题，有时服务端对服务的访问有限制，比如需要指定的客户端才能访问。这个时候我们就可以采取以下两种办法来实现：

(1) public IBinder onBind(Intent intent) 中验证权限，有权限才返回Binder，没有就返回null

@Nullable
@Override
public IBinder onBind(Intent intent) {
Log.d(TAG,"onBind");
if (checkBookServicePermission()){
return mBinder;
}else {
return null;
}
}

/**
* 检查BookServiceDe调用权限
* @return
*/
private boolean checkBookServicePermission(){
int check = checkCallingOrSelfPermission("com.qiyei.ipc.book.ACCESS_BOOK_SERVICE");
return check == PackageManager.PERMISSION_DENIED;
}

其中com.qiyei.ipc.book.ACCESS_BOOK_SERVICE定义在服务端的mainfest文件中：

<!--定义BookService 的权限-->
<permission android:name="com.qiyei.ipc.book.ACCESS_BOOK_SERVICE"
android:protectionLevel="normal"/>
......
<service android:name=".service.BinderPoolService"
android:exported="true"
android:permission="com.qiyei.ipc.book.ACCESS_BOOK_SERVICE">
<intent-filter>
<action android:name="android.intent.action.BINDER_POOL_SERVICE"/>
</intent-filter>
</service>

这样只有客户端有这个权限时才能访问这个服务。

(2)在服务端的Binder对象中onTransact()根据Uid与pid来验证客户端的权限

比如，我们在实现返回的Binder对象中时，重写onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException方法，通过getCallingUid和getCallingPid方法来得到客户端的包名，根据具体的包名来决定是否给予访问的权限，注意，这一条也可以在IBinder onBind(Intent intent)中使用。

/**
* 运行在Binder线程池中
*/
private Binder mBinder = new IBookManager.Stub(){
@Override
public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {

}

@Override
public List<Book> getBookList() throws RemoteException {
Log.d(TAG,"getBookList thread :" + Thread.currentThread().getName());
return mBookList;
}

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

@Override
public void registerListener(IOnNewBookArrivedListener listener) throws RemoteException {
mRemoteCallbackList.register(listener);
Log.d(TAG,"mListenerList size:" + mRemoteCallbackList.beginBroadcast());
mRemoteCallbackList.finishBroadcast();
}

@Override
public void unRegisterListener(IOnNewBookArrivedListener listener) throws RemoteException {
mRemoteCallbackList.unregister(listener);
Log.d(TAG,"mListenerList size:" + mRemoteCallbackList.beginBroadcast());
mRemoteCallbackList.finishBroadcast();
}

@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
String packageName = null;
String[] packages = getPackageManager().getPackagesForUid(getCallingUid());
if (packages != null && packages.length > 0){
packageName = packages[0];
}
Log.d(TAG,"packageName:" + packageName);
if (!packageName.startsWith("com.qiyei.ipc")){
return false;
}

return super.onTransact(code, data, reply, flags);
}
};

上面就是判断包名是否以”com.qiyei.ipc”开头，符合才给予权限访问。

本篇的介绍就到此结束，后续会继续补充，相关代码下载见我的github

源代码下载