【Android原始碼】Binder機制和AIDL分析

指間沙似流年發表於2017-12-14
Android原始碼AI

通常情況下，如果兩個物件能夠直接相互訪問，那麼這兩個物件存在於同一個記憶體空間中。 如果兩個物件分別存在於兩個不同的程式的時候，那麼這兩個物件是不能相互訪問的，這個時候就需要使用跨程式通訊的技術了。 而Android是基於Linux系統的，Linux傳統的跨程式技術主要是Socket，訊號量，管道，訊息佇列等，但是這些技術都有不同的缺點，如Socket開銷大效率不高，管道和訊息佇列拷貝次數多，而對於Android系統來講，更重要的是安全性要高，而這些技術安全性都不是很高，大部分情況下接收方並不能得到傳送發程式的PID/UID，很難識別身份。 所以Android系統就設計出了Binder跨程式通訊機制，來保證傳輸效能和安全性。

Binder

Binder主要模組

Binder主要模組

  1. BinderDriver

    存在於核心空間中，以字元裝置的misc型別註冊，使用者可以從/dev/binder裝置檔案節點上，通過open和ioctl檔案操作函式與BinderDriver進行通訊，主要是負責Binder通訊的建立，程式間的傳遞、Binder引用計數管理/資料包的管理。

  2. BinderClient

    存在於使用者空間中，它和BinderServer的跨程式通訊都是通過BinderDriver來處理轉發的。 對於BinderClient只需要知道自己需要使用的Binder的名字和該Binder在ServerManager中的0號引用就可以了。通過0號引用去訪問ServerManager獲取Binder的引用，得到引用後就可以直接呼叫Binder的方法了。

  3. ServerManager

    存在於使用者空間中，用來管理BinderServer，BinderClient可以通過它來查詢BinderServer介面，查詢到之後就可以獲取到Binder的對映。

  4. BinderServer

    BinderServer會生成一個Binder實體，並會給Binder繫結一個名字，最終封裝成一個資料包傳遞給BinderDriver，BinderDriver在獲取到這個資料包之後，如果發現這個資料包是新傳遞過來的，就會給其在核心空間中建立相應的Binder實體節點和對應的實體節點的引用。 BinderDriver會將Binder的引用傳遞給ServerManager，ServerManager收到後就會取出Binder的名字和引用插入一張資料表中，這個就和DNS儲存域名到IP的對映原理一樣。

系統如何使用Binder

在客戶端中ServerManager的介面定義主要是在IServiceManager中：

public interface IServiceManager extends IInterface
{
    /**
     * Retrieve an existing service called @a name from the
     * service manager.  Blocks for a few seconds waiting for it to be
     * published if it does not already exist.
     */
    public IBinder getService(String name) throws RemoteException;
    
    /**
     * Retrieve an existing service called @a name from the
     * service manager.  Non-blocking.
     */
    public IBinder checkService(String name) throws RemoteException;

    /**
     * Place a new @a service called @a name into the service
     * manager.
     */
    public void addService(String name, IBinder service, boolean allowIsolated)
                throws RemoteException;

    /**
     * Return a list of all currently running services.
     */
    public String[] listServices() throws RemoteException;

    /**
     * Assign a permission controller to the service manager.  After set, this
     * interface is checked before any services are added.
     */
    public void setPermissionController(IPermissionController controller)
            throws RemoteException;
    
    static final String descriptor = "android.os.IServiceManager";

    int GET_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION;
    int CHECK_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+1;
    int ADD_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+2;
    int LIST_SERVICES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+3;
    int CHECK_SERVICES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+4;
    int SET_PERMISSION_CONTROLLER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+5;
}
複製程式碼

可以看到IServiceManager定義的方法主要是新增，獲取，檢查等關於各種服務。主要作用其實就是像上面所說的簡單的將Binder以字元表示的名字轉換成引用。而對於BinderClient的實現其實就是ServiceManagerNative和ServiceManagerProxy，這兩個類實現了該介面，我們在AIDL的時候在分析。

AIDL

我們以具體的例子來分析，首先我們建立相關aidl檔案：

// Book.java
public class Book implements Parcelable {
    public int bookId;
    public String bookName;

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

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

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

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

// Book.aidl
package com.fastaoe.proficient;
parcelable Book;

// IBookManager.aidl
package com.fastaoe.proficient;

import com.fastaoe.proficient.Book;

interface IBookManager {
    List<Book> getBookList();
    void addBook(in Book book);
}
複製程式碼

上面3個檔案，Book.java表示圖書資訊，實現了Parcelable介面。 Book.aidl是Book.java在AIDL中的宣告。 IBookManager是定義了用來操作Book的方法，getBookList從伺服器中獲取圖書列表，addBook向伺服器圖書列表中插入一本新書。 當我們宣告好了AIDL之後，IDE編譯好之後，就生成了IBookManager.java這個類。

public interface IBookManager extends android.os.IInterface {
    // 程式碼省略，下面在分析
}
複製程式碼

可以看到這個系統為我們生成的類，實現了IInterface這個介面，自己本身也是一個介面，我們可以實現這個介面來實現相關的方法。我們來具體分析下這個生成的介面：

private static final java.lang.String DESCRIPTOR = "com.fastaoe.proficient.IBookManager";
複製程式碼

Binder的唯一標識，一般情況下使用當前的類來表示。

public static com.fastaoe.proficient.IBookManager asInterface(android.os.IBinder obj) {
            if ((obj == null)) {
                return null;
            }
            android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
            if (((iin != null) && (iin instanceof com.fastaoe.proficient.IBookManager))) {
                return ((com.fastaoe.proficient.IBookManager) iin);
            }
            return new com.fastaoe.proficient.IBookManager.Stub.Proxy(obj);
        }
複製程式碼

用來將伺服器中的Binder物件轉換成客戶端中所需要的AIDL介面型別的物件。可以看到當客戶端和服務端在同一個程式的時候，返回的就是服務端的Stub本身，如果不在同一個程式，返回的是系統封裝好的Stub.proxy物件，這表示當不在同一個程式的時候，客戶端拿到的其實不是服務端Binder本身，而是一個副本。

public android.os.IBinder asBinder() {
            return this;
        }
複製程式碼

返回Binder物件本身。

public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
       switch (code) {
           case INTERFACE_TRANSACTION: {
               reply.writeString(DESCRIPTOR);
               return true;
           }
           case TRANSACTION_getBookList: {
               data.enforceInterface(DESCRIPTOR);
               java.util.List<com.fastaoe.proficient.Book> _result = this.getBookList();
               reply.writeNoException();
               reply.writeTypedList(_result);
               return true;
           }
           case TRANSACTION_addBook: {
               data.enforceInterface(DESCRIPTOR);
               com.fastaoe.proficient.Book _arg0;
               if ((0 != data.readInt())) {
                   _arg0 = com.fastaoe.proficient.Book.CREATOR.createFromParcel(data);
               } else {
                   _arg0 = null;
               }
               this.addBook(_arg0);
               reply.writeNoException();
               return true;
           }
       }
       return super.onTransact(code, data, reply, flags);
   }
複製程式碼

這個方法執行在伺服器端的Binder執行緒池中，當客戶端發起跨程式的請求的時候，請求會通過底層封裝之後交給此方法執行。伺服器端通過code來判斷客戶端請求的方法是什麼，接著從data中獲取目標方法所需要的資料，並執行目標方法。當方法執行完之後通過reply寫入返回值，最後返回是否成功，如果成功返回true，否則則是false失敗。

private static class Proxy implements com.fastaoe.proficient.IBookManager {
       private android.os.IBinder mRemote;

       Proxy(android.os.IBinder remote) {
           mRemote = remote;
       }

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

       public java.lang.String getInterfaceDescriptor() {
           return DESCRIPTOR;
       }

       @Override
       public java.util.List<com.fastaoe.proficient.Book> getBookList() throws android.os.RemoteException {
           android.os.Parcel _data = android.os.Parcel.obtain();
           android.os.Parcel _reply = android.os.Parcel.obtain();
           java.util.List<com.fastaoe.proficient.Book> _result;
           try {
               _data.writeInterfaceToken(DESCRIPTOR);
               mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
               _reply.readException();
               _result = _reply.createTypedArrayList(com.fastaoe.proficient.Book.CREATOR);
           } finally {
               _reply.recycle();
               _data.recycle();
           }
           return _result;
       }

       @Override
       public void addBook(com.fastaoe.proficient.Book book) throws android.os.RemoteException {
           android.os.Parcel _data = android.os.Parcel.obtain();
           android.os.Parcel _reply = android.os.Parcel.obtain();
           try {
               _data.writeInterfaceToken(DESCRIPTOR);
               if ((book != null)) {
                   _data.writeInt(1);
                   book.writeToParcel(_data, 0);
               } else {
                   _data.writeInt(0);
               }
               mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
               _reply.readException();
           } finally {
               _reply.recycle();
               _data.recycle();
           }
       }
   }
複製程式碼

這個類執行在客戶端中，當客戶端呼叫此方法之後，首先會建立parcel的型別的輸入物件_data，輸出物件_reply，返回值物件_result（如果有的話），接著通過_data將引數儲存起來，在通過transact方法來傳送RPC請求，同時執行緒會被掛起。接著服務端的onTransact方法會呼叫，最終RPC過程返回後，當前執行緒繼續執行，從_reply獲取到返回的結果。

通過AIDL實現跨程式通訊（參考《Android開發藝術探索第二章例子》）

我們把AIDL生成的類分析完之後，就來實現一個伺服器和客戶端通訊的例子吧。

首先定義AIDL檔案，就是上面圖書的例子

其中需要注意的是：

AIDL支援的資料型別：

  • 基本資料型別
  • String和CharSequence
  • ArrayList和HashMap
  • Parcelable
  • AIDL本身

當我們自定義了Parcelable的時候，必須新建一個同名的.aidl檔案，並將其宣告為parcelable型別。 AIDL中所有的實現了Parcelabe介面的類都需要宣告相對應的aidl檔案，並且需要標識in(輸入)、out(輸出)、inout(輸入輸出)。

服務端的實現

public class ServerService extends Service {
    
   private CopyOnWriteArrayList<Book> list = new CopyOnWriteArrayList<>();
   private RemoteCallbackList<IAddBookListener> listeners = new RemoteCallbackList<>();
    
   @Override
   public void onCreate() {
       super.onCreate();
       list.add(new Book(1, "島上書店"));
       list.add(new Book(2, "白夜行"));
   }
    
   @Nullable
   @Override
   public IBinder onBind(Intent intent) {
       return binder;
   }
    
   private IBinder binder = new IBookManager.Stub(){
    
       @Override
       public List<Book> getListBook() throws RemoteException {
           return list;
       }
    
       @Override
       public void addBook(Book book) throws RemoteException {
           onNewBookAdd(book);
       }
    
       @Override
       public void registerListener(IAddBookListener listener) throws RemoteException {
           listeners.register(listener);
       }
    
       @Override
       public void unregisterListener(IAddBookListener listener) throws RemoteException {
           listeners.unregister(listener);
       }
   };
    
   private void onNewBookAdd(Book book) throws RemoteException {
       list.add(book);
       int N = listeners.beginBroadcast();
       for (int i = 0; i < N; i++) {
           IAddBookListener broadcastItem = listeners.getBroadcastItem(i);
           broadcastItem.OnNewBookAddListener(book);
       }
       listeners.finishBroadcast();
   }
}
複製程式碼

在服務端中我們首先初始化了圖書列表，並建立了Binder物件並在onBind中返回。

  1. 使用了CopyOnWriteArrayList，這個List是支援併發讀寫的，因為當多個客戶端同時連線的時候，會出現多個執行緒同時訪問的問題，所以需要在AIDL中處理執行緒問題。

  2. 使用RemoteCallbackList來管理跨程式的listener介面，因為如果使用List的話，並不能在unregister的時候刪除掉當前listener介面，雖然我們使用的看上去是同一個listener，但是其實並不是同一個物件。

    客戶端和服務端在多程式的環境中，而物件是不可能在多程式下傳遞的，所以Binder會將客戶端傳遞過來的物件重新轉化成新的物件，並不是原來的物件，這其實是反序列化的過程，所以AIDL中的自定義物件必須實現Parcelable介面。

    那麼怎麼解除註冊呢？

    可以通過RemoteCallbackList，RemoteCallbackList是系統專門提供用來刪除跨程式listener的介面，在它的內部有一個Map用來儲存所有的AIDL回撥，key是IBinder，value是callback。雖然在跨程式的環境中，生成的物件不是同一個物件，但是它們底層的Binder肯定是同一個，所以可以利用這個來實現解除註冊。當客戶端要解除註冊的時候，服務端通過RemoteCallbackList找到具有相同Binder物件的服務端listener並將其刪除。

客戶端實現

public class MainActivity extends AppCompatActivity {
    
   private List<Book> list = new ArrayList<>();
    
   private int index = 3;
    
   Handler handler = new Handler(){
       @Override
       public void handleMessage(Message msg) {
           switch (msg.what) {
               case 1:
                   list.add((Book) msg.obj);
                   tv_book.setText(list.toString());
                   break;
    
           }
       }
   };
    
   private ServiceConnection conn = new ServiceConnection() {
       @Override
       public void onServiceConnected(ComponentName name, IBinder service) {
           iBookManager = IBookManager.Stub.asInterface(service);
           try {
               iBookManager.registerListener(listener);
           } catch (RemoteException e) {
               e.printStackTrace();
           }
       }
    
       @Override
       public void onServiceDisconnected(ComponentName name) {
           iBookManager = null;
       }
   };
    
   private IBookManager iBookManager;
   private IAddBookListener listener = new IAddBookListener.Stub() {
       @Override
       public void OnNewBookAddListener(Book book) throws RemoteException {
           handler.obtainMessage(1, book).sendToTarget();
       }
   };
   private Button btn_search;
   private Button btn_add;
   private TextView tv_book;
    
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
    
       btn_search = (Button) findViewById(R.id.btn_search);
       btn_add = (Button) findViewById(R.id.btn_add);
       tv_book = (TextView) findViewById(R.id.tv_book);
    
       btn_search.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {
               if (iBookManager != null) {
                   try {
                       // TODO: 2017/7/9 放在子執行緒中 
                       list = iBookManager.getListBook();
                   } catch (RemoteException e) {
                       e.printStackTrace();
                   }
                   tv_book.setText(list.toString());
               }
           }
       });
    
       btn_add.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {
               if (iBookManager != null) {
                   Book book = new Book(index, "圖書"+ index);
                   index += 1;
                   try {
                       // TODO: 2017/7/9 放在子執行緒中 
                       iBookManager.addBook(book);
                   } catch (RemoteException e) {
                       e.printStackTrace();
                   }
               }
           }
       });
    
       Intent intent = new Intent();
       intent.setAction("com.fastaoe.server.ServerService");
       intent.setComponent(new ComponentName("com.fastaoe.server", "com.fastaoe.server.ServerService"));
       bindService(intent, conn, Context.BIND_AUTO_CREATE);
   }
    
   @Override
   protected void onDestroy() {
       try {
           iBookManager.unregisterListener(listener);
       } catch (RemoteException e) {
           e.printStackTrace();
       }
       unbindService(conn);
       super.onDestroy();
   }
}
複製程式碼

首先繫結遠端服務，接著將遠端服務返回的Binder物件轉換成AIDL介面，接著就可以呼叫服務端中的方法了。

  1. 需要注意的是如果aidl中的方法在服務端是耗時的操作的時候，需要處理，不然會導致ANR的產生，同樣的當服務端呼叫客戶端的耗時操作的時候，也需要保證在服務端的方法執行在非UI執行緒，因為Service本身是執行在UI執行緒中的。

  2. OnNewBookAddListener執行在Binder執行緒池中，所以不能在其中訪問UI相關的內容，如果需要訪問的話，則需要通過Handler切換執行緒。

  3. Binder在連線過程中是可能意外死亡的，主要是因為服務端的程式被終止了，所以我們需要重新連線服務。

    1. 可以通過在onServiceDisconnected中重連。
    2. 也可以通過DeathRecipient來監聽是否被斷開。

具體的Demo可以檢視AIDL的簡單實現

相關文章