Android程序間通訊，AIDL工作原理

AIDL 程序間通訊 · 發表 2018-12-10 14:02:49

摘要： 1.前言最近看了AIDL的使用方法，為了加深對AIDL的理解，所以有了手動去編寫AIDL生成的Java檔案。不需要系統自動幫我們建立檔案。大家看的時候，可以對照著AIDL生成的Java檔案去看，看看有哪些不同的地方。為了模擬程序間通訊，我們為service單獨設定一個程...

1.前言

最近看了AIDL的使用方法，為了加深對AIDL的理解，所以有了手動去編寫AIDL生成的Java檔案。不需要系統自動幫我們建立檔案。大家看的時候，可以對照著AIDL生成的Java檔案去看，看看有哪些不同的地方。

為了模擬程序間通訊，我們為service單獨設定一個程序。這裡我是將service和client寫在了同一個app裡面。

2.清單檔案和實體類

2.1 清單檔案

<service
android:name=".binder.BookManagerService"
android:enabled="true"
android:exported="false"
android:process=":remote" />
......
<service
android:name=".binder.BookManagerService"
android:enabled="true"
android:exported="false"
android:process="com.sample.binderstudy.remote" />

這裡通過process 為service指定另外一個程序，用":" 指定的程序，是在程序名前面加上當前應用的包名，並且使用":" 指定的程序，屬於當前應用的私有程序，其他應用的元件不可以和它跑在同一個程序中。而通過"." 去指定完整的程序名，這個程序屬於全域性的程序，這個時候開啟的程序是允許其他程序通過UID與它跑在同一個程序的。兩種寫法都可以，我們隨意選擇一種就好了。

2.2 實體類

package com.sample.binderstudy.binder;

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

class Book implements Parcelable {
private int price;
private String name;

public Book(int price, String name) {
this.price = price;
this.name = name;
}

protected Book(Parcel in) {
price = in.readInt();
name = 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];
}
};

public int getPrice() {
return price;
}

public void setPrice(int price) {
this.price = price;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

@Override
public String toString() {
return "Book{" +
"price=" + price +
", name='" + name + '\'' +
'}';
}

@Override
public int describeContents() {
return 0;
}

@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(price);
dest.writeString(name);
}
}

進行傳輸的實體類，需要實現Parcelable介面。

3.服務端

3.1 IBookManager

import android.os.RemoteException;

import java.util.List;

public interface IBookManager extends IInterface {

String DESCRIPTOR = "com.sample.binderstudy.binder.IBookManager";

int TRANSACTION_addBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
int TRANSACTION_listBook = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);

void addBook(Book book) throws RemoteException;
List<Book> listBook() throws RemoteException;
}

這裡IBookManager繼承IInterface。DESCRIPTOR用來描述Binder的唯一標識，一般以當前Binder的類名標識。接口裡面定義了兩個方法，並且定義了兩個int變數，用來標識請求的是哪一個方法。

3.2 BookManagerImpl

package com.sample.binderstudy.binder;

import android.os.Binder;
import android.os.IBinder;
import android.os.IInterface;
import android.os.Parcel;
import android.os.RemoteException;
import android.support.annotation.NonNull;
import android.util.Log;

import java.util.ArrayList;
import java.util.List;

public class BookManagerImpl extends Binder implements IBookManager {

private static final String TAG = "BookManagerImpl";

private List<Book> books = new ArrayList<>();

public BookManagerImpl() {
this.attachInterface(this, DESCRIPTOR);
}

@Override
public IBinder asBinder() {
return this;
}

public static IBookManager asInterface(android.os.IBinder obj) {
if (obj == null) {
return null;
}
IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if ((iin != null) && (iin instanceof IBookManager)) {
return (IBookManager) iin;
}
return null;
}

@Override
public void addBook(Book book) throws RemoteException {
Log.d(TAG, "service addBook :" + book.toString());
books.add(book);
}

@Override
public List<Book> listBook() throws RemoteException {
Log.d(TAG, "service listBook :");
return books;
}

/**
* 服務端，接收遠端訊息，處理onTransact方法
**/
@Override
protected boolean onTransact(int code, @NonNull Parcel data, Parcel reply, int flags) throws RemoteException {
switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_addBook: {
data.enforceInterface(DESCRIPTOR);
Book _arg0;
if ((0 != data.readInt())) {
_arg0 = Book.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
this.addBook(_arg0);
reply.writeNoException();
return true;
}
case TRANSACTION_listBook: {
data.enforceInterface(DESCRIPTOR);
java.util.List<Book> _result = this.listBook();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
}

這裡需要注意的就是asInterface方法，這個方法是用來將服務端的Binder物件轉化為客戶端所需要的IBookManager介面物件，如果伺服器和客戶端位於相同的程序，則可以直接進行轉化，如果不是，那麼需要進行遠端呼叫。這裡是直接返回的null，為了更好的去區分服務端與客戶端，所以將Proxy類單獨抽出來了。

由於這裡的BookManagerImpl是一個常規類，方法是直接在裡面實現的，與AIDL檔案自動生成的Java檔案不同的是，Stub是一個抽象類，繼而將方法接著抽象了，將方法轉移到了Service裡面讓使用者自己去實現。

3.3 BookManagerService

package com.sample.binderstudy.binder;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.RemoteException;

public class BookManagerService extends Service {

private final BookManagerImpl bookManager = new BookManagerImpl();

@Override
public void onCreate() {
super.onCreate();
new Thread(new AutoTask()).start();
}

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

private class AutoTask implements Runnable {
@Override
public void run() {
int index = 0;
boolean done = false;
try {
while (!done) {
index++;
bookManager.addBook(new Book(index, "Hello" + index));
Thread.sleep(2000);
if (index == 50) {
done = true;
}
}
} catch (RemoteException | InterruptedException e) {
e.printStackTrace();
}
}
}

}

因為程式碼都在BookManagerImpl裡面實現了，所以服務裡面的程式碼異常的簡潔，這與我們通過AIDL去寫的時候有一點不同，不同的是實現的方法轉移到BookManagerImpl裡面去了。

在onCreate方法裡面啟動了一個執行緒，去模擬書籍的新增。

4.客戶端

4.1 BookManagerActivity

package com.sample.binderstudy.binder;

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

import com.sample.binderstudy.R;

public class BookManagerActivity extends AppCompatActivity {
private static final String TAG = "BookManagerActivity";

IBookManager bookManager;

ServiceConnection serviceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
bookManager = BookManagerImpl.asInterface(service);
Log.d(TAG, (bookManager == null) + "");
if (bookManager == null) {
bookManager = new BookManagerProxy(service);
}
try {
for (Book book : bookManager.listBook()) {
Log.e(TAG, "book :" + book.toString());
}
} catch (RemoteException e) {
e.printStackTrace();
}
}

@Override
public void onServiceDisconnected(ComponentName name) {

}
};

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_book_manager);
bindService(new Intent(this, BookManagerService.class), serviceConnection, Context.BIND_AUTO_CREATE);
}
}

程式碼也比較簡潔，在onCreate裡面去繫結我們的遠端服務，這個時候onServiceConnected裡面會返回遠端服務的Binder物件，然後通過BookManagerImpl.asInterface(service)去轉化這個Binder物件，如果返回值為空，表示請求的是遠端服務，那麼我們需要自己手動去初始化BookManagerProxy，然後在這個類裡面去程序遠端呼叫。

通過AIDL生成的Java類，是直接在asInterface裡面去呼叫的Proxy這個類，這個類嚴格意義上來說是跑在客戶端的程序裡面的，所以我才將其從BookManagerImpl裡面抽出來了。AIDL那麼做，應該是出於一個封裝的思路吧，並且將接口裡面要實現的方法拋給了使用者自己去實現，這真的是一個很nice的思路，反正我是寫不出來的~

4.2 BookManagerProxy

package com.sample.binderstudy.binder;

import android.os.Binder;
import android.os.IBinder;
import android.os.Parcel;
import android.os.RemoteException;

import java.util.List;

public class BookManagerProxy extends Binder implements IBookManager{

private IBinder mRemote;

BookManagerProxy(IBinder mRemote) {
this.mRemote = mRemote;
}

@Override
public IBinder asBinder() {
return mRemote;
}

public String getInterfaceDescriptor() {
return DESCRIPTOR;
}

@Override
public void addBook(Book book) throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
if ((book != null)) {
_data.writeInt(1);
book.writeToParcel(_data, 0);
} else {
_data.writeInt(0);
}
mRemote.transact(IBookManager.TRANSACTION_addBook, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}

@Override
public List<Book> listBook() throws RemoteException {
Parcel _data = Parcel.obtain();
Parcel _reply = Parcel.obtain();
List<Book> _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(TRANSACTION_listBook, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(Book.CREATOR);
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
}

在BookManagerProxy裡面，mRemote.transact()去進行遠端操作請求。方法的實現則是在BookManagerImpl的onTransact方法裡面，這樣就完成了程序間的通訊。

5.總結

總體來說，程式碼與AIDL檔案生成的類檔案並無差異，只是類的結構稍有改變，通過AIDL生成的Java檔案，建立的Stub是一個抽象類，這個類將方法的實現拋給了使用者自己去實現，而我是直接在BookManagerImpl裡面實現的，然後將Stub.Proxy類給分離出來了，給拿到了客戶端。雖然我的這種做法比較麻煩，但是是為了更好的理解AIDL才這麼去修改程式碼結構的。

最後呢，AIDL的底層也還是使用Binder來實現的，這個比較複雜，有機會一探究竟。