AIDL
-
服务端创建一个 Service 监听客户端的链接请求，将 AIDL 的实现回调给客户端；
客户端通过 aidl 就可以直接调用服务端的方法
-
AIDL 的声明注意点：
- C/S 两端必须完全一致，包名都不能错，否则找不到
- AIDL 中支持的数据类型不多：
- 基本数据类型、String、char
- List 只支持 ArrayList，Map 只支持 HashMap，且每个元素都必须被 AIDL 所支持
- AIDL 支持的其实是抽象的 List 和 Map，并在最终返回 ArrayList 和 HashMap
- 在 Server 方法中，可以使用其他数据类型，比如 CopyOnWriteArrayList 和 ConcurrentHashMap
- parcelable 对象（必须显示 import）
- 必须声明一个同样的 aidl 文件，声明其为 parcelable 对象
- AIDL 接口本身（必须显示 import）
- 除基本类型外，所有入参必须标明 in / out / inout
- in 代表输入型参数，out 代表输出型参数，inout 表示输入输出型参数
- 只支持方法，不支持静态常量
- AIDL 的方法是在 Binder 线程池中执行的，所以一般需要处理线程同步问题
- 使用 CopyOnWriteArrayList、ConcurrentHashMap、AtomicBoolean
- 如果有接口回调，从 binder 回调到 app
- 使用 aidl 而不是普通接口
- 注册、解注册需要使用 RemoteCallbackListener，而不是常规方式
- 注意 RemoteCallbackListener 的使用，begin & finish 成对使用
- 可以使用权限或者包名的方式，在 onTransact 或者 onBind 方法中校验连接者
AIDL 代码
// IBookManager.aidl
package com.test.testaidl_1;
import com.test.testaidl_1.Book;
import com.test.testaidl_1.IOnNewBookArrivedListener;
interface IBookManager {
List<Book> getBookList();
void addBook(in Book book);
void registerListener(IOnNewBookArrivedListener l);
void unregisterListener(IOnNewBookArrivedListener l);
}
// Book.aidl.aidl
package com.test.testaidl_1;
parcelable Book;
服务端代码
public class BookManagerService extends Service {
private static final String TAG = "bms";
// 线程安全的布尔对象
private AtomicBoolean mIsServiceDestroyed = new AtomicBoolean(false);
// 线程安全的 List
private CopyOnWriteArrayList<Book> mBookList = new CopyOnWriteArrayList<>();
private RemoteCallbackList<IOnNewBookArrivedListener> mListenerList
= new RemoteCallbackList<>();
@Nullable
@Override
public IBinder onBind(Intent intent) {
int check = checkCallingOrSelfPermission("ACCESS_BALABALA");
if (check == PackageManager.PERMISSION_DENIED) {
Log.e(TAG, "permission denied");
return null;
} else {
Log.e(TAG, "permission granted");
}
return mBinder;
}
private Binder mBinder = new IBookManager.Stub() {
@Override
public List<Book> getBookList() throws RemoteException {
// SystemClock.sleep(5000);
return mBookList;
}
@Override
public void addBook(Book book) throws RemoteException {
mBookList.add(book);
}
@Override
public void registerListener(IOnNewBookArrivedListener l) throws RemoteException {
mListenerList.register(l);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
Log.e(TAG, "register list size " + mListenerList.getRegisteredCallbackCount());
}
}
@Override
public void unregisterListener(IOnNewBookArrivedListener l) throws RemoteException {
mListenerList.unregister(l);
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
Log.e(TAG, "register list size " + mListenerList.getRegisteredCallbackCount());
}
}
};
@Override
public void onCreate() {
super.onCreate();
new Thread(new ServiceWorker()).start();
}
private class ServiceWorker implements Runnable {
@Override
public void run() {
while (!mIsServiceDestroyed.get()) {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
int bookId = mBookList.size() + 1;
Book newBook = new Book(bookId, "new Book#" + bookId);
onNewBookArrived(newBook);
}
}
}
private void onNewBookArrived(Book newBook) {
// 运行在 binder 线程池中
SystemClock.sleep(6000);
mBookList.add(newBook);
int size = mListenerList.beginBroadcast();
for (int i = 0; i < size; i++) {
try {
IOnNewBookArrivedListener broadcastItem = mListenerList.getBroadcastItem(i);
if (broadcastItem != null) {
// 客户端回调，如果更新 UI，需要使用 handler 切换线程，否则会报错
broadcastItem.onNewBookArrived(newBook);
}
} catch (RemoteException e) {
e.printStackTrace();
}
}
mListenerList.finishBroadcast();
}
}
客户端代码
public class MainActivity extends AppCompatActivity {
public static final String TAG = "MainActivity";
private IBookManager mBookManager;
private MyListener myListener = new MyListener();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Intent intent = new Intent(this, BookManagerService.class);
bindService(intent, mConn, Context.BIND_AUTO_CREATE);
}
private ServiceConnection mConn = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mBookManager = IBookManager.Stub.asInterface(service);
try {
List<Book> bookList = mBookManager.getBookList();
Log.e(TAG, "query book list, type is " + bookList.getClass().getCanonicalName());
Log.e(TAG, "query book list: " + Arrays.toString(bookList.toArray()));
mBookManager.addBook(new Book(3, "这是本新书"));
Log.e(TAG, "new book");
bookList = mBookManager.getBookList();
Log.e(TAG, "query book list: " + Arrays.toString(bookList.toArray()));
// 这是 UI 线程
mBookManager.registerListener(myListener);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
public void testBinder(View view) {
Toast.makeText(this,"999",Toast.LENGTH_SHORT).show();
// mBookManager.getBookList(); 模拟耗时操作
// 若不放在子线程中，就会 ANR
new Thread(){
@Override
public void run() {
super.run();
try {
List<Book> bookList = mBookManager.getBookList();
Log.e(TAG, "query book list: " + Arrays.toString(bookList.toArray()));
} catch (RemoteException e) {
e.printStackTrace();
}
}
}.start();
}
private class MyListener extends IOnNewBookArrivedListener.Stub {
@Override
public void onNewBookArrived(Book book) throws RemoteException {
// 此方法运行在 Binder 线程的线程池中
// 如果在这里做操作，就会抛异常，不是在 Looper 线程
Toast.makeText(MainActivity.this,
"666",Toast.LENGTH_SHORT).show();
mHandler.obtainMessage(-1, book).sendToTarget();
}
}
private Handler mHandler = new Handler(){
@Override
public void handleMessage(Message msg) {
if (msg.what == -1) {
Log.e(TAG, "收到新书：" + msg.obj.toString());
}
}
};
@Override
protected void onDestroy() {
super.onDestroy();
if (mBookManager != null && mBookManager.asBinder().isBinderAlive()) {
try {
mBookManager.unregisterListener(myListener);
} catch (RemoteException e) {
e.printStackTrace();
}
}
unbindService(mConn);
}
}
以这个 AIDL 实现为例，简单分析一下代码走向。
客户端发起绑定远程服务的请求，经过源码走向，会走向指定的服务信息；
-
服务或者为本地服务，或者为其他应用（远端服务），都会通过 onBind 方法将实例化好的 Binder 对象返回给客户端；
// Stub extends Binder private Binder mBinder = new IBookManager.Stub() {} -
然后代码就会走到客户端的 onServiceConnected 回调：
private ServiceConnection mConn = new ServiceConnection() { @Override public void onServiceConnected(ComponentName name, IBinder service) { mBookManager = IBookManager.Stub.asInterface(service); } }具体我们来看一下系统自动生成的 IBookManager 的 java 类：
public interface IBookManager extends android.os.IInterface { public static abstract class Stub extends Binder implements IBookManager { public Stub() { this.attachInterface(this, DESCRIPTOR); } public static IBookManager asInterface(android.os.IBinder obj) { if ((obj == null)) { return null; } android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin != null) && (iin instanceof IBookManager))) { return ((IBookManager) iin); } return new IBookManager.Stub.Proxy(obj); } @Override public boolean onTransact(... ...) { switch (code) { case TRANSACTION_getBookList: { data.enforceInterface(DESCRIPTOR); java.util.List<com.ljt.testaidl_1.Book> _result = this.getBookList(); reply.writeNoException(); reply.writeTypedList(_result); return true; } } return super.onTransact(code, data, reply, flags); } private static class Proxy implements com.ljt.testaidl_1.IBookManager { private android.os.IBinder mRemote; Proxy(android.os.IBinder remote) { mRemote = remote; } @Override public java.util.List<com.ljt.testaidl_1.Book> getBookList() { Parcel _data = Parcel.obtain(); Parcel _reply = Parcel.obtain(); java.util.List<com.ljt.testaidl_1.Book> _result; try { _data.writeInterfaceToken(DESCRIPTOR); mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0); _reply.readException(); _result = _reply.createTypedArrayList(com.ljt.testaidl_1.Book.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; } } static final int TRANSACTION_getBookList = ... ...; } public java.util.List<com.ljt.testaidl_1.Book> getBookList(); }Stub 类实际上就是个 Binder，用来进行序列化、反序列化操作；Proxy 是服务端在客户端的远程代理，当服务端不在本地时，才会使用到。
-
如果服务在本地，那在 service connect 的时候，Binder 就会找到 aidl 对应的本地实现，并将该对象返回回去；
如果服务不在本地，就会使用代理对象：
public static IBookManager asInterface(android.os.IBinder obj) { android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); if (((iin != null) && (iin instanceof IBookManager))) { return ((IBookManager) iin); } return new IBookManager.Stub.Proxy(obj); } 如果服务在本地，那之后的交互就很简单了，因为对应的实现类已经找到，直接用引用进行调用即可，涉及不到 binder 通信；
-
如果服务在远端，当用户发起方法调用时，会进入到 Proxy 的方法中：
public java.util.List<com.ljt.testaidl_1.Book> getBookList() { Parcel _data = Parcel.obtain(); Parcel _reply = Parcel.obtain(); java.util.List<com.ljt.testaidl_1.Book> _result; try { _data.writeInterfaceToken(DESCRIPTOR); mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0); _reply.readException(); _result = _reply.createTypedArrayList(com.ljt.testaidl_1.Book.CREATOR); } finally { _reply.recycle(); _data.recycle(); } return _result; }根据代码来看，当客户端发起调用时，会先获取两个 Parcel 对象，并且通过 transact 方法传递给服务端。
同时，客户端线程挂起，等待服务端返回数据；
public final boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException { boolean r = onTransact(code, data, reply, flags); return r; }根据 Binder 源码可知，会回调到 onTransact 方法，也就是 Proxy 的 onTransact 方法：
@Override public boolean onTransact(... ...) { switch (code) { case TRANSACTION_getBookList: { data.enforceInterface(DESCRIPTOR); java.util.List<com.ljt.testaidl_1.Book> _result = this.getBookList(); reply.writeNoException(); reply.writeTypedList(_result); return true; } } return super.onTransact(code, data, reply, flags); }经过 onTransact 方法的处理，会像 reply 的 parcel 对象中写入返回值，之后该方法返回 true 唤醒客户端，继续执行，从而完成整个调用。
以上，大概就是使用 AIDL 进行 binder 通信的过程。
