Android学习小Demo（23）Aidl实现进程间通信

我们知道，Android是靠Binder机制来实现进程间的通信，而上一篇文章中，我们利用AIDL，简单地从代码方面的角度讲解了在服务端中的Binder的存在形式，是以服务的实现存在的，而在客户端，则是以代理的形式，实现存在的只是一个关于服务端的Binder实现的引用。

理论上的东西我们要去学习掌握，但是也不能忽略了实际的动手能力，对吧。

今天，我们就一步一步地利用我们所了解地关于AIDL的知识来实现一个跨进程通信的例子。

在Android的上层应用中，每一个App都是一个单独的进程，所以，要实现跨进程通信，我们需要至少有2个进程，一个代表服务端，一个代表客户端，所以我们会创建2个项目，来分别代表服务端和客户端。

服务端是提供服务的，得先提供服务，才能让客户端来享受服务，对吧。

服务端

我们创建一个服务端的项目，然后创建我们的aidl文件，毕竟只是一个Demo，所以我先从简单入手，方法不要太多，就叫IDemoService.aidl, 如下：

[java] view plaincopy

1. package com.lms.service;
3. interface IDemoService {
4.     void invoke();
5. }

我们将其放在com.lms.service的包名目录下，表明其是提供服务的，当我们编译一下项目之后，就会发现在gen目录下面同样的包名下，生成了一个IDemoService.java的文件，如下：

而其生成的IDemoService.java文件内容如下，跟上一篇文章中所展现的其实一样，就是一个Stub类和一个Proxy类，如下：

[java] view plaincopy

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

既然已经通过aidl生成了这份接口文件，那么根据上一篇文章所讲的，我们接下来就要来实现服务端这边提供的服务了。

我们可以想到，当我们在使用Android中的服务接口的时候，当其需要与其他模块进行相互通信的时候，我们一般是会通过绑定的形式实现的，而通过此种形式的实现，我们都会实现一个Binder，比如我们之前音乐播放器的实现，如下：

[java] view plaincopy

1. class NatureBinder extends Binder{
3.         /**
4.          * 唱吧，有人想听
5.          */
6.         public void startPlay(int currentMusic, int currentPosition){}
8.         /**
9.          * 别唱了
10.          */
11.         public void stopPlay(){}
12.         /**
13.          * 后一首
14.          */
15.         public void toNext(){}
17.         /**
18.          * 前一首
19.          */
20.         public void toPrevious(){}
22.         /**
23.          * 有人改变模式了，我得把它记下来 
24.          */
25.         public void changeMode(){}
27.         /**
28.          * 告诉别人，你现在到底是顺序播放，还是随机乱弹
29.          * MODE_ONE_LOOP = 1;
30.          * MODE_ALL_LOOP = 2;
31.          * MODE_RANDOM = 3;
32.          * MODE_SEQUENCE = 4; 
33.          * @return
34.          */
35.         public int getCurrentMode(){}
37.         /**
38.          * 告诉调用者，到底有没有在做事。。。
39.          * @return
40.          */
41.         public boolean isPlaying(){}
43.         /**
44.          * 要告诉调用者，当前播哪首歌了，歌多长啊
45.          */
46.         public void notifyActivity(){}
48.         /**
49.          * 有人拖动Seekbar了，要告诉service去改变播放的位置
50.          * @param progress
51.          */
52.         public void changeProgress(int progress){}
53.     }

在上面这种情况下，Service是与同一个进程中的其他线程或者模块进行通信的，而在我们这种跨进程的服务中是不是也可以类似自己去实现我们AIDL中的定义的Stub类呢？

因为Stub类也是继承Binder的，而Binder又是实现了IBinder接口的，所以可以在调用Service的onBinde方法的时候，就返回我们实现的服务呀，对吧。

所以我们自定义一个服务，就叫做DemoService，如下：

[java] view plaincopy

1. package com.lms.service;
3. import android.app.Service;
4. import android.content.Intent;
5. import android.os.IBinder;
7. public class DemoService extends Service{
9.     @Override
10.     public IBinder onBind(Intent intent) {
11.         // TODO Auto-generated method stub
12.         return null;
13.     }
15. }

Service是一个抽象类，继承它必须实现其抽象方法 onBinde，其会返回一个IBinder对象，那么很显然，我们就需要在这个方法里返回我们的Binder了。

下面，我们先简单实现我们的Binder，如下：

[java] view plaincopy

1. public class DemoService extends Service {
3.     private static final String TAG = “DemoService”;
5.     public final IDemoService.Stub mBinder = new IDemoService.Stub() {
7.         @Override
8.         public void invoke() throws RemoteException {
9.             Log.v(TAG, “Invoke -> Current Process From Server: “ + android.os.Process.myPid());
10.         }
11.     };
13.     @Override
14.     public IBinder onBind(Intent intent) {
15.         Log.v(TAG, “Bind -> Current Process From Server: “ + android.os.Process.myPid());
16.         return mBinder;
17.     }
19.     public boolean onUnbind(Intent intent){
20.         Log.v(TAG, “Unbind -> Current Process From Server: “ + android.os.Process.myPid());
21.         return super.onUnbind(intent);
22.     }
23. }

最后，在AndroidManifest.xml中注册Service，如下：

[html] view plaincopy

1. <service
2.     android:name=“com.lms.service.DemoService”
3.     android:exported=“true”
4.     android:process=“:remote” >
5.     <intent-filter>
6.         <category android:name=“android.intent.category.DEFAULT” />
8.         <action android:name=“com.lms.service.DemoService” />
9.     </intent-filter>
10. </service>

在这里，我们还需要定义一个intent-filter，以便Android系统在第三方调用的时候，可以通过隐式的intent来匹配到这个服务，同时还要注意两点：

1）android:process 必须设置值，至于什么值，好像关系并不大，表明可接受远程调用

2）android:exported设置为true，这表明此组件可供第三方调用，不过对于Service来说，这默认就是true的，所以我们不设也可以。但是对于Activity等来说，其值是默认为false的，这时候，如果我们想让我们的Activity为第三方调用，就要显式设置为true了。通常，在接入第三方插件的时候，我们会用到这个属性。

OK，到这里为止，我们已经简单地实现了我们的服务端服务了，接下来我们再继续实现我们客户端。

再创建一个项目，AidlDemoClient，然后将我们在服务端的这份aidl文件，包括包名等，复制到客户端代码中，编译一下，其会生成一份一样的java文件，不过此时，我们不再需要去实现Stub类了，我们只是需要去调用这个类就可以了，如下：

接着，我们只需要像平常一样调用我们的Service就可以了，所不同的是，由于这服务并不在我们进程内，所以我们必须用隐式的Intent去调用，由系统去匹配服务，从而调起，这也是为什么我们在服务端注册Service的时候，需要设置IntentFilter的原因了。

[java] view plaincopy

1. public class MainActivity extends ActionBarActivity {
3.     private static final String TAG = “DemoService”;
4.     private static final String ACTION_BIND_SERVICE = “com.lms.service.DemoService”;
6.     private IDemoService mDemoService;
8.     private ServiceConnection mServiceConnection = new ServiceConnection() {
10.         @Override
11.         public void onServiceDisconnected(ComponentName name) {
12.             mDemoService = null;
13.         }
15.         @Override
16.         public void onServiceConnected(ComponentName name, IBinder service) {
17.             mDemoService = IDemoService.Stub.asInterface(service);
18.             try {
19.                 mDemoService.invoke();
20.             } catch (RemoteException e) {
21.                 // TODO Auto-generated catch block
22.                 e.printStackTrace();
23.             }
24.         }
25.     };
27.     @Override
28.     protected void onCreate(Bundle savedInstanceState) {
29.         super.onCreate(savedInstanceState);
30.         setContentView(R.layout.activity_main);
32.         Button btnHelloWorld = (Button) findViewById(R.id.btnBind);
33.         btnHelloWorld.setOnClickListener(new OnClickListener() {
35.             @Override
36.             public void onClick(View v) {
37.                 Intent intentService = new Intent(ACTION_BIND_SERVICE);
38.                 intentService.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
39.                 bindService(intentService, mServiceConnection, BIND_AUTO_CREATE);
40.                 Log.v(TAG, “Current Process From Client: “ + android.os.Process.myPid());
41.             }
42.         });
44.         Button btnUnbind = (Button) findViewById(R.id.btnUnbind);
45.         btnUnbind.setOnClickListener(new OnClickListener() {
47.             @Override
48.             public void onClick(View v) {
49.                 if(mServiceConnection != null){
50.                     unbindService(mServiceConnection);
51.                     mServiceConnection = null;
52.                 }
53.             }
54.         });
56.     }

我们定义了两个按钮，当点击的时候，分别通过隐式的intent去启动服务并触发方法和解除绑定，我们可以看到在onServiceConnected中，我们利用了IDemoService.Stub.asInterface() 方法来实例化这个Binder，至于asterface是如何跨进程找到这个binder的，我们上一篇文章中已经简单地讲了一下。

接下来，我们可以启动这两个应用，来试一下啦。

从上面的画面中，我们可以看到，点击事件发生的线程ID是685，而真正接受服务和触发Invoke方法的是在进程676上面，于是我们就实现了跨进程通信了。

当然在这里，我们只是做了一个很简单的调用而已，而实际上我们还能够传递参数和接受返回值，而这些我们都可以在aidl文件中定义，不过要注意的是:

1）aidl中直接提供的数据类型只支持基本的数据类型和String

2）如果要支持我们自己的自定义的对象，我们的对象必须也通过aidl来定义，而且实现parceable接口，如下：

[java] view plaincopy

1. package com.lms.aidl;
3. import java.util.List;
4. import com.lms.aidl.Bean;
6. interface ITestService {
8.     List<Bean> getBean();
10.     void addBean(in Bean bean);
11. }

而Bean的aidl文件如下：

[java] view plaincopy

1. package com.lms.aidl;
3. parcelable Bean;

其具体实现如下：

[java] view plaincopy

1. package com.lms.aidl;
3. import android.os.Parcel;
4. import android.os.Parcelable;
6. public class Bean implements Parcelable {
8.     private int i;
9.     private String str;
11.     public Bean(){
13.     }
15.     /**
16.      * @return the i
17.      */
18.     public int getI() {
19.         return i;
20.     }
22.     /**
23.      * @param i the i to set
24.      */
25.     public void setI(int i) {
26.         this.i = i;
27.     }
29.     /**
30.      * @return the str
31.      */
32.     public String getStr() {
33.         return str;
34.     }
36.     /**
37.      * @param str the str to set
38.      */
39.     public void setStr(String str) {
40.         this.str = str;
41.     }
43.     public Bean(Parcel in) {
44.         readFromParcel(in);
45.     }
47.     public static final Parcelable.Creator<Bean> CREATOR = new Parcelable.Creator<Bean>() {
49.         public Bean createFromParcel(Parcel in) {
50.             return new Bean(in);
51.         }
53.         public Bean[] newArray(int size) {
54.             return new Bean[size];
55.         }
57.     };
59.     @Override
60.     public int describeContents() {
61.         return 0;
62.     }
64.     @Override
65.     public void writeToParcel(Parcel dest, int flags) {
66.         dest.writeInt(i);
67.         dest.writeString(str);
68.     }
70.     public void readFromParcel(Parcel in) {
71.         i = in.readInt();
72.         str = in.readString();
73.     }
74. }

而我们可以从其通信的过程中拿到服务端的数据，如下：

好了，关于aidl的使用，我们就简单地介绍到这里吧，我会把两份Demo的代码都放上来，大家如果有兴趣，可以自己拿去参考一下。

简单版（只是调用方法）：AidlDemo简单版

进阶版（进程间通信并且传递自定义对象）：AidlDemo进阶版

转自：http://blog.csdn.net/linmiansheng/article/details/42835229

Share this: