AIDL
AIDL 是 Android 跨进程通信的一种方式
AIDL 支持类型
- 基本数据类型：char、byte、short、int、long、float、double、boolean
- String，CharSequence
- 实现了 Parcelable 接口的类型
- List 类型和Map类型，要求里面的每个元素都是 AIDL 支持的类型
AIDL 文件分类
- 在 AIDL 中声明实现了 Parcelable 接口的数据类型
- 定义接口方法，声明要暴露哪些接口给客户端调用
参数定向TAG
所有的非基本参数都需要一个定向 tag 来指出数据的流向，不管是 in , out , 还是 inout 。基本参数的定向 tag 默认是并且只能是 in
- in ：表示数据只能由客户端流向服务端
- out ：表示数据只能由服务端流向客户端
- inout ：表示数据可在服务端与客户端之间双向流通
使用AIDL
在 java 文件夹下定义 AIDL 需要使用到的数据类型
Book.kt
@Parcelize
data class Book(val bookId: Int, val bookName: String) : Parcelable
在 aidl 文件夹中声明需要使用到的数据类型
Book.aidl
// Book.aidl
// 声明实现了 Parcelable 接口的数据类型，注意这里的包名要和Book类的包名对应
package com.example.androidstudy.aidl_study;
// Declare any non-default types here with import statements
parcelable Book;
IOnNewBookArrivedListener.aidl 用于添加监听
// IOnNewBookArrivedListener.aidl
package com.example.androidstudy;
import com.example.androidstudy.Book;
// Declare any non-default types here with import statements
interface IOnNewBookArrivedListener {
void onNewBookArrived(in Book book);
}
定义 AIDL 接口方法，声明要暴露哪些接口给客户端调用
// IBookManager.aidl
package com.example.androidstudy;
import com.example.androidstudy.Book;
import com.example.androidstudy.IOnNewBookArrivedListener;
// Declare any non-default types here with import statements
interface IBookManager {
List getBookList();
void addBook(in Book book);
void registerListener(IOnNewBookArrivedListener listener);
void unregisterListener(IOnNewBookArrivedListener listener);
}
服务端
class AidlServerService : Service() {
// 返回给客户端的binder，实现提供给客户端访问的接口
object ServerBinder : IBookManager.Stub() {
private val serverBookList = mutableListOf()
private val listenerList = mutableListOf()
override fun getBookList(): MutableList {
// 这里的方法运行在Binder线程池中，因此需要线程同步
synchronized(this) {
return serverBookList
}
}
override fun addBook(book: Book) {
synchronized(this) {
serverBookList.add(book)
// 通知注册监听了的客户端，添加了新书
listenerList.forEach {
it.onNewBookArrived(book)
}
}
}
override fun registerListener(listener: IOnNewBookArrivedListener?) {
synchronized(this) {
if (listener != null && !listenerList.contains(listener)) {
listenerList.add(listener)
}
}
}
override fun unregisterListener(listener: IOnNewBookArrivedListener?) {
synchronized(this) {
listenerList.remove(listener)
}
}
}
override fun onBind(intent: Intent): IBinder {
return ServerBinder
}
}
客户端
class AidlClientActivity : AppCompatActivity() {
companion object {
private const val TAG = "AidlClientActivity"
}
private var bookManager: IBookManager? = null
//要绑定的服务Intent
private val serverIntent = Intent("com.example.androidstudy.aidl_study").apply {
setPackage("com.example.androidstudy")
}
// 服务连接
private val serviceConnection = MyServiceConnection()
// Binder的死亡代理
private val deathRecipient = object : IBinder.DeathRecipient {
override fun binderDied() {
bookManager?.also {
it.asBinder().unlinkToDeath(this, 0)
}
bookManager = null
// 重新绑定远程Service
bindService(serverIntent, serviceConnection, BIND_AUTO_CREATE)
}
}
// 新书的监听
private val listener = object : IOnNewBookArrivedListener.Stub() {
override fun onNewBookArrived(book: Book) {
newBookText.text = "bookId=${book.bookId} bookName=${book.bookName}"
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_aidl_client)
// 绑定AIDL服务端
bindService(serverIntent, serviceConnection, BIND_AUTO_CREATE)
// 添加书籍
addBook.setOnClickListener {
bookManager?.apply {
addBook(Book(bookList.size, bookEditText.text.toString()))
}
}
// 获取书籍
getAllBook.setOnClickListener {
bookManager?.apply {
val builder = StringBuilder()
bookList.forEach {
builder.appendLine("bookId=${it.bookId} bookName=${it.bookName}")
}
allBookText.text = builder.toString()
}
}
}
inner class MyServiceConnection : ServiceConnection {
override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
Log.d(TAG, "onServiceConnected: ")
// 获取服务端提供服务的接口
bookManager = IBookManager.Stub.asInterface(service)
bookManager?.registerListener(listener)
// 绑定死亡代理
service?.linkToDeath(deathRecipient, 0)
}
// 该方法只在 Service 被杀死的时候调用
override fun onServiceDisconnected(name: ComponentName?) {
Log.d(TAG, "onServiceDisconnected: ")
}
}
}
AIDL生成类
客户端发起远程请求，会调用 IBookManager.Stub.Proxy 的对应实现方法，在这个方法里，创建了 Parcel 对象 _data、输出型 Parcel 对象 _reply 和返回值对象 List，将参数写入 _data 中，调用 transact 方法来发起 RPC ，同时当前线程挂起，然后服务端的 onTransact 方法会被调用，在 onTransact 中，调用服务端提供的服务方法，写入结果，回到客户端的 transact ，将结果从 _reply 读出并返回
public interface IBookManager extends android.os.IInterface {
public static abstract class Stub extends android.os.Binder implements com.example.androidstudy.IBookManager {
private static final java.lang.String DESCRIPTOR = "com.example.androidstudy.IBookManager";
// 在客户端的onServiceConnected回调中调用，用于将IBinder转换为服务端提供的接口服务
public static com.example.androidstudy.IBookManager asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.example.androidstudy.IBookManager))) {
return ((com.example.androidstudy.IBookManager) iin);
}
return new com.example.androidstudy.IBookManager.Stub.Proxy(obj);
}
/**
* 运行在服务端中的Binder线程池中，当客户端发起跨进程请求时，远程请求会通过系统底层封装后交由此方法来处理
* @param code 用于确定客户端请求的哪一个方法
* @param data 用于获取参数
* @param reply 用于写入返回值
* @param flags
* @return 如果返回false，那么客户端的请求会失败
* @throws android.os.RemoteException
*/
@Override
public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
java.lang.String descriptor = DESCRIPTOR;
switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(descriptor);
return true;
}
case TRANSACTION_getBookList: {
data.enforceInterface(descriptor);
java.util.List _result = this.getBookList();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
case TRANSACTION_addBook: {
data.enforceInterface(descriptor);
com.example.androidstudy.aidl_study.Book _arg0;
if ((0 != data.readInt())) {
_arg0 = com.example.androidstudy.aidl_study.Book.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
this.addBook(_arg0);
reply.writeNoException();
return true;
}
default: {
return super.onTransact(code, data, reply, flags);
}
}
}
private static class Proxy implements com.example.androidstudy.IBookManager {
// 运行在客户端，创建该方法所需要的输入型Parcel对象_data、输出型Parcel对象_reply和返回值对象List
// 把该方法的参数信息写入_data中，调用transact方法来发起RPC，同时当前线程挂起；然后服务端的onTransact方法会被调用
// 直到RPC过程返回后，当前线程继续执行，并从_reply中取出RPC过程的返回结果；最后返回_reply中的数据
@Override
public java.util.List getBookList() throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.util.List _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
boolean _status = mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
if (!_status && getDefaultImpl() != null) {
return getDefaultImpl().getBookList();
}
_reply.readException();
_result = _reply.createTypedArrayList(com.example.androidstudy.aidl_study.Book.CREATOR);
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
}
static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}
public java.util.List getBookList() throws android.os.RemoteException;
public void addBook(com.example.androidstudy.aidl_study.Book book) throws android.os.RemoteException;
}