android進程間通信:使用AIDL

     歡迎閱讀本文,你能關注本文,你知道你需要進程間通信、需要AIDL(以及Binder),那麼可以默認你對這些概念已經有了一些瞭解,你(大致)知道它們是什麼,它們有什麼用,所以爲了節約大家的眼力和時間,在此我不復制粘貼網上氾濫的博客或者翻譯冗長的android文檔。

      關於AIDL的介紹在文檔:docs/guide/developing/tools/aidl.html

      關於IBinder的介紹在文檔:docs/reference/android/os/IBinder.html

      以及Binder:docs/reference/android/os/Binder.html

      在後文中,我將以我自己的理解向你介紹相關的概念。以我目前粗淺的經驗,應用程序使用AIDL的地方,幾乎都和Service有關,所以你也需要知道一些關於Service的知識。日後得閒我也會繼續寫一些關於Service的貼。

      本文將以一個例子來和你分享使用AIDL的基礎技能,這個例子裏有:

1、一個類mAIDLActivity,繼承Activity。裏面有三個按鈕,text分別爲StartService,StopService,CallbackTest。

2、一個類mAIDLService,繼承Service。爲了充分展示ADIL的功能,它做以下工作:當用戶點擊CallbackTest按鈕時,從mAIDLActivity調用mAIDLService中的Stub 對象的一個方法invokCallBack(),而這個方法又會調用mAIDLActivity中Stub 對象的一個方法performAction(),這個方法在屏幕上顯示一個toast。沒什麼意義,只是展示一下AIDL如何使用。

3、兩個AIDL文件:forService.aidl和forActivity.aidl。對應名字,在Service和Activity中分別有對象需要用到它們定義的接口。

4、相關XML文件,略過。關於manifest中Service的語法,見docs/guide/topics/manifest/service-element.html。你也可以簡單地在<application></application>中加入

     <service android:name=".mAIDLService" android:process=":remote"> </service>

開發環境爲Eclipse。

揀重要的先說,來看看aidl文件的內容:

文件:forActivity.aidl

  1. package com.styleflying.AIDL;  
  2. interface forActivity {  
  3.     void performAction();  
  4.     }  
 

文件:forService.aidl

  1. package com.styleflying.AIDL;  
  2. import com.styleflying.AIDL.forActivity;  
  3. interface forService {  
  4.     void registerTestCall(forActivity cb);  
  5.     void invokCallBack();  
  6. }  
 

這兩個文件和Java文件放置的地方一樣,看包名。

在Eclipse中它們將被自動編譯爲forActivity.java和forService.java,它們存放在gen目錄下。爲了方便手頭無法演練的讀者,代碼貼上,不用細看。

文件forActivity.java:

  1. /* 
  2.  * This file is auto-generated.  DO NOT MODIFY. 
  3.  * Original file: D://workspace//AIDLTest//src//com//styleflying//AIDL//forActivity.aidl 
  4.  */  
  5. package com.styleflying.AIDL;  
  6. import java.lang.String;  
  7. import android.os.RemoteException;  
  8. import android.os.IBinder;  
  9. import android.os.IInterface;  
  10. import android.os.Binder;  
  11. import android.os.Parcel;  
  12. public interface forActivity extends android.os.IInterface  
  13. {  
  14. /** Local-side IPC implementation stub class. */  
  15. public static abstract class Stub extends android.os.Binder implements com.styleflying.AIDL.forActivity  
  16. {  
  17. private static final java.lang.String DESCRIPTOR = "com.styleflying.AIDL.forActivity";  
  18. /** Construct the stub at attach it to the interface. */  
  19. public Stub()  
  20. {  
  21. this.attachInterface(this, DESCRIPTOR);  
  22. }  
  23. /** 
  24.  * Cast an IBinder object into an forActivity interface, 
  25.  * generating a proxy if needed. 
  26.  */  
  27. public static com.styleflying.AIDL.forActivity asInterface(android.os.IBinder obj)  
  28. {  
  29. if ((obj==null)) {  
  30. return null;  
  31. }  
  32. android.os.IInterface iin = (android.os.IInterface)obj.queryLocalInterface(DESCRIPTOR);  
  33. if (((iin!=null)&&(iin instanceof com.styleflying.AIDL.forActivity))) {  
  34. return ((com.styleflying.AIDL.forActivity)iin);  
  35. }  
  36. return new com.styleflying.AIDL.forActivity.Stub.Proxy(obj);  
  37. }  
  38. public android.os.IBinder asBinder()  
  39. {  
  40. return this;  
  41. }  
  42. @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException  
  43. {  
  44. switch (code)  
  45. {  
  46. case INTERFACE_TRANSACTION:  
  47. {  
  48. reply.writeString(DESCRIPTOR);  
  49. return true;  
  50. }  
  51. case TRANSACTION_performAction:  
  52. {  
  53. data.enforceInterface(DESCRIPTOR);  
  54. this.performAction();  
  55. reply.writeNoException();  
  56. return true;  
  57. }  
  58. }  
  59. return super.onTransact(code, data, reply, flags);  
  60. }  
  61. private static class Proxy implements com.styleflying.AIDL.forActivity  
  62. {  
  63. private android.os.IBinder mRemote;  
  64. Proxy(android.os.IBinder remote)  
  65. {  
  66. mRemote = remote;  
  67. }  
  68. public android.os.IBinder asBinder()  
  69. {  
  70. return mRemote;  
  71. }  
  72. public java.lang.String getInterfaceDescriptor()  
  73. {  
  74. return DESCRIPTOR;  
  75. }  
  76. public void performAction() throws android.os.RemoteException  
  77. {  
  78. android.os.Parcel _data = android.os.Parcel.obtain();  
  79. android.os.Parcel _reply = android.os.Parcel.obtain();  
  80. try {  
  81. _data.writeInterfaceToken(DESCRIPTOR);  
  82. mRemote.transact(Stub.TRANSACTION_performAction, _data, _reply, 0);  
  83. _reply.readException();  
  84. }  
  85. finally {  
  86. _reply.recycle();  
  87. _data.recycle();  
  88. }  
  89. }  
  90. }  
  91. static final int TRANSACTION_performAction = (IBinder.FIRST_CALL_TRANSACTION + 0);  
  92. }  
  93. public void performAction() throws android.os.RemoteException;  
  94. }  

文件forService.java:

兩段代碼差不多,前面基本一樣,從後面看,最後跟着我們在AIDL中自定義的方法,沒有實現。兩個文件各定義一個了接口,這兩個接口分別會在Activity和Service中使用,在那裏我們將實現自定義的方法。兩個接口中都定義了一個抽象類Stub,實現所在的接口。Stub中又有一個類Proxy。Stub中有一個static的asInterface()方法,裏面有很多return語句,在mAIDLActivity中調用它時,它返回一個新創建的內部類Proxy對象。

這個Stub對我們來說很有用,它繼承了Binder。Binder有什麼用呢?一個類,繼承了Binder,那麼它的對象就可以被遠程的進程使用了(前提是遠程進程獲取了這個類的對象【對象的引用】,至於如如何獲得看下文),在本例中就是說,如果一個Service中有一個繼承了Stub的類的對象,那麼這個對象中的方法就可以在Activity中使用,對Activity也是這樣。至於Binder的細節,網上有很多貼介紹,看不明白也不影響我們完成這個例子。

再看mAIDLActivity.java:

  1. package com.styleflying.AIDL;  
  2. import android.app.Activity;  
  3. import android.content.ComponentName;  
  4. import android.content.Context;  
  5. import android.content.Intent;  
  6. import android.content.ServiceConnection;  
  7. import android.os.Bundle;  
  8. import android.os.IBinder;  
  9. import android.os.RemoteException;  
  10. import android.util.Log;  
  11. import android.view.View;  
  12. import android.view.View.OnClickListener;  
  13. import android.widget.Button;  
  14. import android.widget.Toast;  
  15. public class mAIDLActivity extends Activity {  
  16.     private static final String TAG = "AIDLActivity";  
  17.     private Button btnOk;  
  18.     private Button btnCancel;  
  19.     private Button btnCallBack;  
  20.       
  21.     private void Log(String str) {  
  22.         Log.d(TAG, "------ " + str + "------");  
  23.         }  
  24.       
  25.     private forActivity mCallback = new forActivity.Stub() {  
  26.         public void performAction() throws RemoteException  
  27.         {  
  28.             Toast.makeText(mAIDLActivity.this"this toast is called from service"1).show();  
  29.         }  
  30.         };  
  31.           
  32.     forService mService;  
  33.     private ServiceConnection mConnection = new ServiceConnection() {  
  34.         public void onServiceConnected(ComponentName className,  
  35.                 IBinder service) {  
  36.             mService = forService.Stub.asInterface(service);  
  37.             try {  
  38.                 mService.registerTestCall(mCallback);}  
  39.             catch (RemoteException e) {  
  40.                   
  41.             }  
  42.             }  
  43.         public void onServiceDisconnected(ComponentName className) {  
  44.             Log("disconnect service");  
  45.             mService = null;  
  46.             }  
  47.         };  
  48.     @Override  
  49.     public void onCreate(Bundle icicle) {  
  50.         super.onCreate(icicle);  
  51.         setContentView(R.layout.main);  
  52.         btnOk = (Button)findViewById(R.id.btn_ok);  
  53.         btnCancel = (Button)findViewById(R.id.btn_cancel);  
  54.         btnCallBack = (Button)findViewById(R.id.btn_callback);  
  55.         btnOk.setOnClickListener(new OnClickListener() {  
  56.             public void onClick(View v) {  
  57.                 Bundle args = new Bundle();  
  58.                 Intent intent = new Intent(mAIDLActivity.this, mAIDLService.class);  
  59.                 intent.putExtras(args);  
  60.                 bindService(intent, mConnection, Context.BIND_AUTO_CREATE);  
  61.                 startService(intent);  
  62.                 }  
  63.             });  
  64.         btnCancel.setOnClickListener(new OnClickListener() {  
  65.             public void onClick(View v) {  
  66.                 unbindService(mConnection);  
  67.                 //stopService(intent);   
  68.                 }  
  69.             });  
  70.         btnCallBack.setOnClickListener(new OnClickListener() {  
  71.               
  72.             @Override  
  73.             public void onClick(View v)  
  74.             {  
  75.                 try  
  76.                 {  
  77.                     mService.invokCallBack();  
  78.                 } catch (RemoteException e)  
  79.                 {  
  80.                     // TODO Auto-generated catch block   
  81.                     e.printStackTrace();  
  82.                 }  
  83.             }  
  84.         });  
  85.         }  
  86. }  

 

很短,相信大家很容易看明白。注意mConnection,它的onServiceConnected()中有一句mService = forService.Stub.asInterface(service);給mService賦值了,這個mService是一個forService,而service是onServiceConnected()傳進來的參數,onServiceConnected()會在連接Service的時候被系統調用,這個service參數的值來自哪裏呢?看mAIDLService.java:

  1. package com.styleflying.AIDL;  
  2. import android.app.Service;  
  3. import android.content.Intent;  
  4. import android.os.IBinder;  
  5. import android.os.RemoteCallbackList;  
  6. import android.os.RemoteException;  
  7. import android.util.Log;  
  8. public class mAIDLService extends Service {  
  9.     private static final String TAG = "AIDLService";    
  10.     private forActivity callback;  
  11.     private void Log(String str) {  
  12.         Log.d(TAG, "------ " + str + "------");  
  13.     }  
  14.     @Override  
  15.     public void onCreate() {  
  16.         Log("service create");  
  17.     }  
  18.     @Override  
  19.     public void onStart(Intent intent, int startId) {  
  20.         Log("service start id=" + startId);  
  21.     }  
  22.       
  23.     @Override  
  24.     public IBinder onBind(Intent t) {  
  25.         Log("service on bind");  
  26.         return mBinder;  
  27.     }  
  28.     @Override  
  29.     public void onDestroy() {  
  30.         Log("service on destroy");  
  31.         super.onDestroy();  
  32.     }  
  33.     @Override  
  34.     public boolean onUnbind(Intent intent) {  
  35.         Log("service on unbind");  
  36.         return super.onUnbind(intent);  
  37.     }  
  38.     public void onRebind(Intent intent) {  
  39.         Log("service on rebind");  
  40.         super.onRebind(intent);  
  41.     }  
  42.     private final forService.Stub mBinder = new forService.Stub() {  
  43.         @Override  
  44.         public void invokCallBack() throws RemoteException  
  45.         {  
  46.             callback.performAction();  
  47.               
  48.         }  
  49.         @Override  
  50.         public void registerTestCall(forActivity cb) throws RemoteException  
  51.         {  
  52.             callback = cb;  
  53.               
  54.         }  
  55.           
  56.     };  
  57. }  

注意onBind(),它的返回類型爲IBinder,返回了一個mBinder,看看mBinder的定義:

    private final forService.Stub mBinder = new forService.Stub() {

        @Override
        public void invokCallBack() throws RemoteException
        {
            callback.performAction();
         }

        @Override
        public void registerTestCall(forActivity cb) throws RemoteException
        {
            callback = cb;

        }

       };

它是實現了我們在AIDL中定義的方法,這個mBinder最終返回給了mAIDLActivity中的mService,於是在mAIDLActivity中可以使用mBinder中的方法了。在mAIDLActivity中也有一個類似mBinder的對象,看看定義:   

        private forActivity mCallback = new forActivity.Stub()

    {
        public void performAction() throws RemoteException
        {
            Toast.makeText(mAIDLActivity.this, "this toast is called from service", 1).show();
        }
      };

我們要在界面上顯示一個toast,就是在這裏實現的。這個對象,在mConnection的onServiceConnected()被調用時,通過調用mService(也就是遠程的mAIDLService中的mBinder)的registerTestCall(),傳遞給了mAIDLService,於是在mAIDLService中可以調用performAction()了。

很囉嗦,只爲了能把這個細節說清楚。請大家認真看,我儘量避免錯別字、混亂的大小寫和邏輯不清的語法,相信你會看明白。是不是很簡單?再囉嗦一下,做一個大致總結,我們使用AIDL是要做什麼呢:

讓Acticity(或者說一個進程/一個類?)和Service(或者說遠端進程/遠端類/對象?)獲取對方的一個Stub對象,這個對象在定義時實現了我們在AIDL中定義的方法,於是這些遠程對象中的方法可以在本地使用了。如果這種使用(通信)是單向的,比如只是Activity需要通知Service做什麼,那麼只要Service中有一個Stub對象,並且傳給Acticity就夠了。

至於如何獲得遠程的Stub,參看上面的代碼,看mConnection、registerTestCall、onRebind,它們展示了一種方法。

另外,有時候我們可能在一個類中有多個Stub對象,它們都要給遠程交互的類的實例,這個時候可以考慮使用RemoteCallbackList<>(docs/reference/android/os/RemoteCallbackList.html)。

歡迎閱讀、收藏本文。例子隨手寫的,功能只在演示AIDL的使用。您可以轉載本文,但請勿盲目亂貼。不是我小氣,我不權威,我怕它被貼到氾濫,以訛傳訛,害了人。

 

轉載:http://blog.csdn.net/saintswordsman/article/details/5130947

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章