AIDL

在Android中，如果我们需要在不同进程间实现通信，就需要用到AIDL技术去完成。

AIDL（Android Interface Definition Language）是一种接口定义语言，编译器通过*.aidl文件的描述信息生成符合通信协议的Java代码，我们无需自己去写这段繁杂的代码，只需要在需要的时候调用即可，通过这种方式我们就可以完成进程间的通信工作。关于AIDL的编写规则我在这里就不多介绍了，读者可以到网上查找一下相关资料。

接下来，我就演示一个操作AIDL的最基本的流程。

首先，我们需要建立一个服务端的工程，如图所以：

 

在IPerson.aidl中我们定义了一个“问候”的方法，代码如下：

[java] view plain copy
 
  1. package com.scott.aidl;  
  2. interface IPerson {  
  3.     String greet(String someone);  
  4. }  

 

在Eclipse插件的帮助下，编译器会自动在gen目录中生成对应的IPerson.java文件，格式化后的代码如下：

 

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

 

该文件的大纲视图如下：

IPerson接口中的抽象内部类Stub继承android.os.Binder类并实现IPerson接口，比较重要的方法是asInterface(IBinder)方法，该方法会将IBinder类型的对象转换成IPerson类型，必要的时候生成一个代理对象返回结果。

接下来就是我们的Service了：

 

[java] view plain copy
 
  1. package com.scott.server;  
  2.   
  3. import android.app.Service;  
  4. import android.content.Intent;  
  5. import android.os.IBinder;  
  6. import android.os.RemoteException;  
  7. import android.util.Log;  
  8.   
  9. import com.scott.aidl.IPerson;  
  10.   
  11. public class AIDLService extends Service {  
  12.   
  13.     private static final String TAG = "AIDLService";  
  14.       
  15.     IPerson.Stub stub = new IPerson.Stub() {  
  16.         @Override  
  17.         public String greet(String someone) throws RemoteException {  
  18.             Log.i(TAG, "greet() called");  
  19.             return "hello, " + someone;  
  20.         }  
  21.     };  
  22.       
  23.     @Override  
  24.     public IBinder onBind(Intent intent) {  
  25.         Log.i(TAG, "onBind() called");  
  26.         return stub;  
  27.     }  
  28.       
  29.     @Override  
  30.     public boolean onUnbind(Intent intent) {  
  31.         Log.i(TAG, "onUnbind() called");  
  32.         return true;  
  33.     }  
  34.       
  35.     @Override  
  36.     public void onDestroy() {  
  37.         super.onDestroy();  
  38.         Log.i(TAG, "onDestroy() called");  
  39.     }  
  40. }  

 

我们实现了IPerson.Stub这个抽象类的greet方法，然后再onBind(Intent)方法中返回我们的stub实例，这样一来调用方获取的IPerson.Stub就是我们的这个实例，greet方法也会按照我们的期望那样执行。

当然，要想让Service生效，我们还需要在AndroidManifest.xml中做一些配置工作：

 

[java] view plain copy
 
  1. <service android:name=".AIDLService">  
  2.     <intent-filter>  
  3.         <action android:name="android.intent.action.AIDLService" />  
  4.              <category android:name="android.intent.category.DEFAULT" />  
  5.     </intent-filter>  
  6. </service>  

 

服务端已经完成了，接下来我们就该完成客户端的工作了。我已经建好了一个客户端工程，如图：

我们只需要把IPerson.aidl文件拷到相应的目录中即可，编译器同样会生成相对应的IPerson.java文件，这一部分和服务端没什么区别。这样一来，服务端和客户端就在通信协议上达到了统一。我们主要工作在MainActivity中完成。

MainActivity代码如下：

 

[java] view plain copy
 
  1. package com.scott.client;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.ComponentName;  
  5. import android.content.Context;  
  6. import android.content.Intent;  
  7. import android.content.ServiceConnection;  
  8. import android.os.Bundle;  
  9. import android.os.IBinder;  
  10. import android.os.RemoteException;  
  11. import android.util.Log;  
  12. import android.view.View;  
  13. import android.widget.Button;  
  14. import android.widget.Toast;  
  15.   
  16. import com.scott.aidl.IPerson;  
  17.   
  18. public class MainActivity extends Activity {  
  19.   
  20.     private Button bindBtn;  
  21.     private Button greetBtn;  
  22.     private Button unbindBtn;  
  23.   
  24.     private IPerson person;  
  25.     private ServiceConnection conn = new ServiceConnection() {  
  26.   
  27.         @Override  
  28.         public void onServiceConnected(ComponentName name, IBinder service) {  
  29.             Log.i("ServiceConnection", "onServiceConnected() called");  
  30.             person = IPerson.Stub.asInterface(service);  
  31.         }  
  32.   
  33.         @Override  
  34.         public void onServiceDisconnected(ComponentName name) {  
  35.             //This is called when the connection with the service has been unexpectedly disconnected,  
  36.             //that is, its process crashed. Because it is running in our same process, we should never see this happen.  
  37.             Log.i("ServiceConnection", "onServiceDisconnected() called");  
  38.         }  
  39.     };  
  40.   
  41.     @Override  
  42.     public void onCreate(Bundle savedInstanceState) {  
  43.         super.onCreate(savedInstanceState);  
  44.         setContentView(R.layout.main);  
  45.   
  46.         bindBtn = (Button) findViewById(R.id.bindBtn);  
  47.         bindBtn.setOnClickListener(new View.OnClickListener() {  
  48.             @Override  
  49.             public void onClick(View v) {  
  50.                 Intent intent = new Intent("android.intent.action.AIDLService");  
  51.                 bindService(intent, conn, Context.BIND_AUTO_CREATE);  
  52.                   
  53.                 bindBtn.setEnabled(false);  
  54.                 greetBtn.setEnabled(true);  
  55.                 unbindBtn.setEnabled(true);  
  56.             }  
  57.         });  
  58.   
  59.         greetBtn = (Button) findViewById(R.id.greetBtn);  
  60.         greetBtn.setOnClickListener(new View.OnClickListener() {  
  61.             @Override  
  62.             public void onClick(View v) {  
  63.                 try {  
  64.                     String retVal = person.greet("scott");  
  65.                     Toast.makeText(MainActivity.this, retVal, Toast.LENGTH_SHORT).show();  
  66.                 } catch (RemoteException e) {  
  67.                     Toast.makeText(MainActivity.this, "error", Toast.LENGTH_SHORT).show();  
  68.                 }  
  69.             }  
  70.         });  
  71.   
  72.         unbindBtn = (Button) findViewById(R.id.unbindBtn);  
  73.         unbindBtn.setOnClickListener(new View.OnClickListener() {  
  74.             @Override  
  75.             public void onClick(View v) {  
  76.                 unbindService(conn);  
  77.                   
  78.                 bindBtn.setEnabled(true);  
  79.                 greetBtn.setEnabled(false);  
  80.                 unbindBtn.setEnabled(false);  
  81.             }  
  82.         });  
  83.     }  
  84. }  

 

从代码中可以看到，我们要重写ServiceConnection中的onServiceConnected方法将IBinder类型的对像转换成我们的IPerson类型。到现在我们就剩下最后一个步骤了，这个环节也是最为关键的，就是绑定我们需要的服务。我们通过服务端Service定义的“android.intent.action.AIDLService”这个标识符来绑定其服务，这样客户端和服务端就实现了通信的连接，我们就可以调用IPerson中的“问候”方法了。

最后，贴几张客户端演示过程图。

 

 

 

 按照顺序分别是：初始界面；点击bindService后界面；点击greet后界面；点击unbindService后界面。

操作过程中的日志如下：

 
 

posted on 2016-02-23 20:39  梦若在心就在  阅读(141)  评论(0)  编辑  收藏  举报

导航