Service之跨进程调用服务ADIL详解(一)

1，概述

      Android系统中的各应用程序都运行在各自的进程中，进程之间通常是无法直接交换数据的。

      Android提供了跨进程调用Service的功能，称为AIDL（android interface define language）Android接口定义语言。

      ADIL相当与两个进程通信的协议，通过这个协议对进程间的通信进行了规范。按照该规范编写代码即可实现进程间的通信。

 

2，AIDL 接口文件

      跨进程调用服务中需要定义接口文件，扩展名为.aidl

      1、在项目的src文件夹下定义一个AIDL接口文件。

      2、AIDL接口的内部语法与Java很相似，后面会演示

      3、.aidl接口文件创建后，Android系统会自动生成主文件名相同的.java接口文件。该文件在项目的gen文件夹下，该文件不能修改，是Android自动生成的。

 

3，具体操作

      因为是跨进程的通信协议，需要创建两个项目，一个项目是后台程序，一个是启动该后台服务的客户端，通过启动这两个项目来演示2个进程间的通信。

 

步骤1：创建Service项目，将该项目中的Activity类删除，把AndroidManifest.xml中的activity配置删除。

步骤2：创建AIDL接口文件：

     a,创建一个包，在该包下创建java类，IMyService.java

 

Java代码  

1. package com.example.aidl;  
2. interface IMyService {  
3.     void play();  
4.     void pause();  
5. }  

     

    b,将IMyService.java改名为IMyService.aidl。(需要到项目代码路径中去修改)

      注意：

       1.aidl文件中不能出现访问修饰符，如public

       2.aidl文件(包括所在包)在两个项目中要完全一致

 

     c,修改后刷新项目，得到如下图情况

 

    其中，IMyService.java是Android根据IMyService.aidl文件自动生成的接口，打开该文件查看源代码如下：

    

  说明：

  标注1- Stub类是IMyService接口的内部抽象类，该类继承了Binder类。

  标注2- 这是Stub类中的asInterface方法，该方法负责将service返回至client的对象转换为IMyService.Stub。。。。

  标注3-  指向的两个方法是步骤2定义的IMyService接口中声明的两个方法。

  
 步骤3：新建包结构，自定义AIDLService.java类，该类继承Service类。

Java代码  

1. package com.example.aidlService;  
2.   
3. import com.example.aidl.IMyService;  
4.   
5. import android.app.Service;  
6. import android.content.Intent;  
7. import android.os.Binder;  
8. import android.os.IBinder;  
9. import android.os.RemoteException;  
10. import android.util.Log;  
11.   
12. public class AIDLService extends Service {  
13.   
14.     private static final String tag = "AIDLService";  
15.     private MyBinder mBinder;  
16.   
17.     @Override  
18.     public IBinder onBind(Intent intent) {  
19.         Log.i(tag, "...service onBind()...");  
20.         return mBinder;  
21.     }  
22.   
23.      /*  
24.      * 该类继承了IMyService.Stub类而不是extends Binder类。 
25.      * IMyService.Stub是Binder的子类。 
26.      * 进程内的Service定义MyBinder内部类是继承Binder类。 
27.      */  
28.     public class MyBinder extends IMyService.Stub {  
29.         @Override  
30.         public void play() throws RemoteException {  
31.             AIDLService.this.play();  
32.         }  
33.         @Override  
34.         public void pause() throws RemoteException {  
35.             AIDLService.this.pause();  
36.         }  
37.     }  
38.     @Override  
39.     public void onCreate() {  
40.         super.onCreate();  
41.         //创建MyBinder对象，并在onBind()方法中返回该对象  
42.                 mBinder = new MyBinder();  
43.         Log.i(tag, "service onCreate()...");  
44.     }  
45.     private void play() {  
46.         Log.i(tag, "service 自定义 play()...");  
47.     }  
48.     private void pause() {  
49.         Log.i(tag, "service 自定义 pause()...");  
50.     }  
51.     @Override  
52.     public int onStartCommand(Intent intent, int flags, int startId) {  
53.         Log.i(tag, "service onStartCommand...");  
54.         return super.onStartCommand(intent, flags, startId);  
55.     }  
56.     @Override  
57.     public boolean onUnbind(Intent intent) {  
58.         Log.i(tag, "service onUnbind()...");  
59.         return super.onUnbind(intent);  
60.     }  
61. }  

 

在AndroidManifet.xml中注册Service。

Java代码  

1. <service android:name="com.example.aidlService.AIDLService" >  
2.     <intent-filter>  
3.         <action android:name="com.example.service.aidl" />  
4.     </intent-filter>  
5. </service>  
6.   
7. 注意，这里指定action，提供给其他进程来访问 -->  

 

 步骤4：创建Client项目，界面如下：

 

步骤5：将Service项目中创建的IMyService.aidl接口连包一起复制到Client项目中。结果如下图：

 

 

步骤6：在Client项目中的MainActivity.java中调用Service项目中的服务。

Java代码  

1. public class MainActivity extends Activity implements OnClickListener {  
2.     Button btnBind, btnPlay, btnPause;  
3.     IMyService mBinder; // 接口的一个引用  
4.     boolean mIsBind = false; // 绑定值为true,未绑定制为false;  
5.     private ServiceConnection mConn = new ServiceConnection() {  
6.   
7.         @Override  
8.         public void onServiceDisconnected(ComponentName name) {  
9.         }  
10.   
11.         @Override  
12.         public void onServiceConnected(ComponentName name, IBinder service) {  
13.             /* 
14.              * 获得另一个进程中的Service传递过来的IBinder对象-service， 
15.              * 用IMyService.Stub.asInterface方法转换该对象，这点与进程内的通信不同 
16.              */  
17.             mBinder = IMyService.Stub.asInterface(service);  
18.             mIsBind = true;  
19.             Log.i("MainActivity", "onServiceConnected....");  
20.         }  
21.     };  
22.   
23.     @Override  
24.     protected void onCreate(Bundle savedInstanceState) {  
25.         super.onCreate(savedInstanceState);  
26.         setContentView(R.layout.activity_main);  
27.         btnBind = (Button) findViewById(R.id.btn_bind);  
28.         btnPlay = (Button) findViewById(R.id.btn_play);  
29.         btnPause = (Button) findViewById(R.id.btn_pause);  
30.         btnBind.setOnClickListener(this);  
31.         btnPlay.setOnClickListener(this);  
32.         btnPause.setOnClickListener(this);  
33.     }  
34.   
35.     @Override  
36.     public void onClick(View v) {  
37.         Intent intent = new Intent();  
38.         int btn = v.getId();  
39.         switch (btn) {  
40.         case R.id.btn_bind:  
41.             intent.setAction(Constant.ACTION_AIDL);  
42.             bindService(intent, mConn, BIND_AUTO_CREATE);  
43.             break;  
44.         case R.id.btn_play:  
45.             if (mIsBind){  
46.                 try {  
47.                     mBinder.play();  
48.                 } catch (RemoteException e) {  
49.                     e.printStackTrace();  
50.                 }//调用service中的play()  
51.             }  
52.                 break;  
53.         case R.id.btn_pause:  
54.             if(mIsBind){  
55.                 try {  
56.                     mBinder.pause();  
57.                 } catch (Exception e) {  
58.                     e.printStackTrace();  
59.                 }  
60.             }  
61.             break;  
62.         }  
63.     }  
64. }  

 

结果：当依次点击按钮时，会调用Service项目中定义的服务。

 
常见问题:

1,跨进程绑定服务与本地绑定服务的对比

    跨进程调用并绑定服务与绑定本地（同一应用程序内部的服务称为本地服务）服务有所不同。

   1） 绑定本地服务是：本地的Service通过onBinder方法将装载数据的IBinder对象传递给客户端的ServiceConnection对象的ServiceConnected方法的第二个参数service。并用Service中的内部类（自定义类）进行转换，从而获得从服务中返回的对象，通过调用该对象中的方法或属性值达到与被绑定的服务交换数据和控制该服务的目的。

   2）跨进程绑定服务，首先要定义一个扩展名是 aidl 的接口问，该接口文件中申明了帮绑定服务所提供的方法。这个接口文件要复制到客户端程序中。

        在服务总定义内部类时，不是直接继承 Binder 类，而是继承 接口.Stub 类（因Stub类已继承了Binder）。

        在客户端的onServiceConnected方法中用IMyService.Stub.asInterface()方法转换服务器端传递过来的对象。

mBinder = IMyService.Stub.asInterface(service);

 

2，使用AIDL无法实现进程间通讯

   两个项目的aidl文件不在同一个包中。

   

3，在AndroidManifest.xml文件中配置AIDL服务，注意<action>标签中的android.name 的属性值就是客户端要引用该服务的ID，也就是Intent.setAction("xxxxxxx");（或者Intent构造方法的参数）。注意，这里在Client进程中不能通过new Intent(context,IMyService.class) 来启动。